def new_population(problem_type: str, old_population: list,
mutated_children: list, evaluator):
"""
Genereaza o populatie noua dupa urmatoarele reguli:
-se pastreaza toti copiii obtinuti dupa mutatii(acestia se repara in cazul problemei de tip knapsack)
-locurile libere din populatie se vor umple cu parintii ramasi
:param problem_type: poate avea valorile "knapsack" sau "tsp"
:param old_population: populatia precedenta
:param mutated_children: copiii obtinuti dupa mutatie
:param evaluator: in cazul unei probleme de tip Kanpsack va avea contine o lista de obiecte si capacitatea maxima
in cazul uneil probleme de tip TSP va contine matricea de distante
:return population: noua popullatie obtinuta
"""
population = []
mc = mutated_children[:]
if problem_type == "knapsack":
for i in range(len(mc)):
if not Knapsack.is_valid(evaluator[0], mc[i], evaluator[1]):
mc[i] = Knapsack.make_it_valid(evaluator[0], mc[i],
evaluator[1])
population = old_population + mc
population = sorted(
population,
key=lambda x: Knapsack.fitness(evaluator[0], x, evaluator[1]),
reverse=True)
elif problem_type == "tsp":
population = old_population + mc
population = sorted(population,
key=lambda x: TSP.fitness_TSP(x, evaluator),
reverse=False)
population = population[:len(old_population)]
return population
def evaluate_population(problem_type: str, population: list,
population_size: int, evaluator):
"""
Evaluarea populatiei pentru a obtine best, average si worst
:param problem_type: poate avea valorile "knapsack" sau "tsp"
:param population: populatia evaluata
:param population_size: marimea populatiei
:param evaluator: in cazul unei probleme de tip Kanpsack va avea contine o lista de obiecte si capacitatea maxima
in cazul uneil probleme de tip TSP va contine matricea de distante
:return best: cel mai bun fitness din populatie
:return avg: valoare medie pentru fitness-ul populatie
:return worst: cel mai slab fitness din populatie
"""
best, avg, worst = 0, 0, 0
if problem_type == "knapsack":
eval_population = sorted(
population,
key=lambda x: Knapsack.fitness(evaluator[0], x, evaluator[1]),
reverse=True)
best = Knapsack.fitness(evaluator[0], eval_population[0], evaluator[1])
for i in range(population_size):
avg += Knapsack.fitness(evaluator[0], eval_population[i],
evaluator[1])
avg /= population_size
worst = Knapsack.fitness(evaluator[0], eval_population[-1],
evaluator[1])
elif problem_type == "tsp":
eval_population = sorted(population,
key=lambda x: TSP.fitness_TSP(x, evaluator),
reverse=False)
best = TSP.fitness_TSP(eval_population[0], evaluator)
for i in range(population_size):
avg += TSP.fitness_TSP(eval_population[i], evaluator)
avg /= population_size
worst = TSP.fitness_TSP(eval_population[-1], evaluator)
return best, avg, worst
def selection(problem_type: str, population: list, population_size: int,
evaluator):
"""
Aici se selecteaza un parinte din populatia initiala. Se foloseste selectia turnir de marime 5.
:param population_size: marimea populatiei
:param problem_type: poate avea valorile "knapsack" sau "tsp"
:param population: populatia initiala
:param evaluator: in cazul unei probleme de tip Kanpsack va avea contine o lista de obiecte si capacitatea maxima
in cazul uneil probleme de tip TSP va contine matricea de distante
:return parent: lista
"""
parent1, parent2 = [], []
p = population[:] # copie a populatiei initiale
for i in range(2):
sample = np.random.default_rng().choice(population_size,
size=2,
replace=False)
possible_parents = [p[s] for s in sample]
if sample[0] > sample[1]:
sample[0], sample[1] = sample[1], sample[0]
del p[sample[0]]
del p[sample[1] - 1]
population_size -= 2
parent = []
if problem_type == "knapsack":
parent = sorted(
possible_parents,
key=lambda x: Knapsack.fitness(evaluator[0], x, evaluator[1]),
reverse=True)
elif problem_type == "tsp":
parent = sorted(possible_parents,
key=lambda x: TSP.fitness_TSP(x, evaluator),
reverse=False)
if i == 0:
parent1 = parent[0]
else:
parent2 = parent[0]
return parent1, parent2
