def find_best_individual(self, population):
if len(population) == 0:
population = self.generate_population(self.generate_population)
try:
population[0] = sorted(population[0], key=lambda x: x[2], reverse=True)
population[1] = sorted(population[1], key=lambda x: x[2], reverse=True)
best_type_A = population[0][0]
best_type_B = population[1][0]
except:
population = self.generate_population(self.population_size)
population[0] = sorted(population[0], key=lambda x: x[2], reverse=True)
population[1] = sorted(population[1], key=lambda x: x[2], reverse=True)
best_type_A = population[0][0]
best_type_B = population[1][0]
if best_type_A[2] > best_type_B[2]:
fitness1 = compute_fitness(self.title, self.sentences, best_type_A[0], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns,self.order_params)
fitness2 = compute_fitness(self.title, self.sentences, best_type_A[1], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
if fitness1 >= fitness2:
return (best_type_A[0], fitness1)
else:
return (best_type_A[1], fitness2)
return (best_type_B[0], best_type_B[2])
def find_best_individual(self, population, final_res):
try:
population[0] = sorted(population[0], key=lambda x: x[2], reverse=True)
population[1] = sorted(population[1], key=lambda x: x[2], reverse=True)
best_type_A = population[0][0]
best_type_B = population[1][0]
if best_type_A[2] > best_type_B[2]:
fitness1 = compute_fitness(self.title, self.sentences, best_type_A[0], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
fitness2 = compute_fitness(self.title, self.sentences, best_type_A[1], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
if fitness1 >= fitness2:
best = (best_type_A[0], fitness1)
else:
best = (best_type_A[1], fitness2)
else:
best = (best_type_B[0], best_type_B[2])
if best[1] >= final_res[2]:
return best
else:
fitness1 = compute_fitness(self.title, self.sentences, final_res[0], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
fitness2 = compute_fitness(self.title, self.sentences, final_res[1], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
if fitness1 >= fitness2:
best = (final_res[0], fitness1)
else:
best = (final_res[1], fitness2)
return best
except:
return None
def mutate(self, individual, max_sent):
sum_sent_in_summary = sum(individual[0])
sum_sent_in_summary2 = sum(individual[1])
if len(individual[1]) == 0:
self.mutation_rate = 2 / self.num_objects
chromosome = individual[0][:]
for i in range(len(chromosome)):
if random.random(
) < self.mutation_rate and sum_sent_in_summary < max_sent:
if chromosome[i] == 0:
chromosome[i] = 1
sum_sent_in_summary += 1
# else:
# chromosome[i] = 0
# sum_sent_in_summary -=1
fitness = compute_fitness(self.title, self.sentences, chromosome,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns)
return (chromosome, individual[1], fitness)
if random.random() < 0.05:
chromosome = random.choice(individual[:-1])
null_chromosome = []
fitness = compute_fitness(self.title, self.sentences, chromosome,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns)
return (chromosome, null_chromosome, fitness)
chromosome1 = individual[0][:]
chromosome2 = individual[1][:]
self.mutation_rate = 1 / self.num_objects
for i in range(len(chromosome1)):
if random.random(
) < self.mutation_rate and sum_sent_in_summary < max_sent:
if chromosome1[i] == 0:
chromosome1[i] = 1
sum_sent_in_summary += 1
# else:
# chromosome1[i] = 0
# sum_sent_in_summary -=1
for i in range(len(chromosome2)):
if random.random(
) < self.mutation_rate and sum_sent_in_summary2 < max_sent:
if chromosome2[i] == 0:
chromosome2[i] = 1
sum_sent_in_summary2 += 1
else:
chromosome2[i] = 0
sum_sent_in_summary2 -= 1
fitness1 = compute_fitness(self.title, self.sentences, chromosome1,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns)
fitness2 = compute_fitness(self.title, self.sentences, chromosome2,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns)
fitness = max(fitness1, fitness2)
return (chromosome1, chromosome2, fitness)
def PSO(self):
W = 0.5
c1 = 0.5
c2 = 0.9
n_iterations = 30
max_sent = 4
if len(self.sentences) < 4:
max_sent = len(self.sentences)
gbest_position = np.zeros(self.num_objects)
gbest_position[np.random.choice(list(range(self.num_objects)), self.num_picked_sents, replace=False)] = 1
gbest_position = gbest_position.tolist()
gbest_fitness_value = compute_fitness(self.title, self.sentences, gbest_position, self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
#init population
population = self.generate_population(self.population_size)
for i in tqdm(range(n_iterations)):
for i, individual in enumerate(population):
individual = list(individual)
fitness_candidate = compute_fitness(self.title, self.sentences, individual[0], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
if fitness_candidate > individual[1]:
individual[1] = fitness_candidate
individual[2] = individual[0] #pbest of individual
if fitness_candidate > gbest_fitness_value:
gbest_fitness_value = fitness_candidate
gbest_position = individual[0]
population[i] = tuple(individual)
for i, individual in enumerate(population):
individual = list(individual)
particle_position_vector = np.array(individual[0])
pbest_position = np.array(individual[2])
velocity_vector = np.array(individual[3])
gbest = np.array(gbest_position)
# new_velocity = (W*velocity_vector) + (c1*random.random())*(pbest_position - particle_position_vector) + (c2*random.random())*(gbest - particle_position_vector)
new_velocity = (W*velocity_vector) + (c1*random.random())*self.subtraction(pbest_position , particle_position_vector) + (c2*random.random())*self.subtraction(gbest , particle_position_vector)
new_velocity = new_velocity.tolist()
individual[3] = self.normalize(new_velocity)
new_velocity = np.array(individual[3])
particle_position_vector = self.subtraction(particle_position_vector, new_velocity)
individual[0] = self.reduce_mem(particle_position_vector.tolist(), max_sent)
population[i] = tuple(individual)
populationGA = self.solveGA(population)
populationGA = sorted(populationGA, key=lambda x: x[1], reverse=True)
populationPSO = sorted(population, key=lambda x: x[1], reverse=True)
combine = int(self.population_size/2)
population = populationPSO[: combine ]
for individual in populationGA[ : combine] :
population.append(individual)
return self.find_best_individual(population)
def crossover(self, individual_1, individual_2, max_sent):
if self.num_objects < 2 or random.random() >= self.crossover_rate:
return individual_1[:], individual_2[:]
crossover_point = 1 + random.randint(0, self.num_objects - 2)
agent_1 = individual_1[0][:crossover_point] + individual_2[0][
crossover_point:]
fitness_1 = compute_fitness(self.title, self.sentences, agent_1,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.simWithAbs, self.rougeforsentences,
self.order_params)
child_1 = (agent_1, fitness_1)
sum_sent_in_summary = sum(child_1[0])
if sum_sent_in_summary > max_sent:
while (sum_sent_in_summary > max_sent):
remove_point = 1 + random.randint(0, self.num_objects - 2)
if agent_1[remove_point] == 1:
agent_1[remove_point] = 0
sent = self.sentences[remove_point]
sum_sent_in_summary -= 1
fitness_1 = compute_fitness(self.title, self.sentences, agent_1,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.simWithAbs,
self.rougeforsentences,
self.order_params)
child_1 = (agent_1, fitness_1)
crossover_point_2 = 1 + random.randint(0, self.num_objects - 2)
agent_2 = individual_2[0][:crossover_point_2] + individual_1[0][
crossover_point_2:]
fitness_2 = compute_fitness(self.title, self.sentences, agent_2,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.simWithAbs, self.rougeforsentences,
self.order_params)
child_2 = (agent_2, fitness_2)
sum_sent_in_summary_2 = sum(child_2[0])
if sum_sent_in_summary_2 > max_sent:
while (sum_sent_in_summary_2 > max_sent):
remove_point = 1 + random.randint(0, self.num_objects - 2)
if agent_2[remove_point] == 1:
agent_2[remove_point] = 0
sent = self.sentences[remove_point]
sum_sent_in_summary_2 -= 1
fitness_2 = compute_fitness(self.title, self.sentences, agent_2,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.simWithAbs,
self.rougeforsentences,
self.order_params)
child_2 = (agent_2, fitness_2)
return child_1, child_2
def generate_population(self, amount):
# print("Generating population...")
population = []
typeA = []
typeB = []
# for i in range(int(amount/2)):
for i in range(amount):
#creat type A
chromosome1 = np.zeros(self.num_objects)
chromosome1[np.random.choice(list(range(self.num_objects)),
self.num_picked_sents,
replace=False)] = 1
chromosome1 = chromosome1.tolist()
fitness1 = compute_fitness(self.title, self.sentences, chromosome1,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.order_params)
chromosome2 = np.zeros(self.num_objects)
chromosome2[np.random.choice(list(range(self.num_objects)),
self.num_picked_sents,
replace=False)] = 1
chromosome2 = chromosome2.tolist()
fitness2 = compute_fitness(self.title, self.sentences, chromosome2,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.order_params)
fitness = max(fitness1, fitness2)
life_time = 0
age = 0
typeA.append((chromosome1, chromosome2, fitness, life_time, age))
#creat type B
chromosome3 = np.zeros(self.num_objects)
chromosome3[np.random.choice(list(range(self.num_objects)),
self.num_picked_sents,
replace=False)] = 1
chromosome3 = chromosome3.tolist()
fitness3 = compute_fitness(self.title, self.sentences, chromosome3,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.order_params)
chromosome4 = []
typeB.append((chromosome3, chromosome4, fitness3, life_time, age))
population.append(typeA)
population.append(typeB)
return population
def generate_population(self, amount):
# print("Generating population...")
population = []
for i in range(amount):
#position
agent = np.zeros(self.num_objects)
agent[np.random.choice(list(range(self.num_objects)),
self.num_picked_sents,
replace=False)] = 1
agent = agent.tolist()
#p_best_position
pbest_position = agent
#p_best_value
fitness = compute_fitness(self.title, self.sentences, agent,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns)
#velocity
velocity = np.zeros(self.num_objects)
velocity[np.random.choice(list(range(self.num_objects)),
self.num_picked_sents,
replace=False)] = 1
velocity = velocity.tolist()
# print("fitness: {:.4f}" , format(fitness))
# print(agent)
population.append((agent, fitness, pbest_position, velocity))
return population
def crossover(self, individual_1, individual_2, max_sent):
# check tỷ lệ crossover
if self.num_objects < 2 or random.random() >= self.crossover_rate:
return individual_1[:], individual_2[:]
#tìm điểm chéo 1
crossover_point = 1 + random.randint(0, self.num_objects - 2)
agent_1a = individual_1[0][:crossover_point] + individual_2[0][crossover_point:]
fitness_1a = compute_fitness(self.title, self.sentences, agent_1a, self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
agent_1b = individual_2[0][:crossover_point] + individual_1[0][crossover_point:]
fitness_1b = compute_fitness(self.title, self.sentences, agent_1b, self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
velocity = np.zeros(self.num_objects)
velocity = velocity.tolist()
if fitness_1a > fitness_1b:
child_1 = (agent_1a, fitness_1a, agent_1a, velocity, 0, 0)
else:
child_1 = (agent_1b, fitness_1b, agent_1a, velocity, 0, 0)
sum_sent_in_summary = sum(child_1[0])
agent_1 = child_1[0]
fitness_1 = child_1[1]
if sum_sent_in_summary > max_sent:
while(sum_sent_in_summary > max_sent):
remove_point = 1 + random.randint(0, self.num_objects - 2)
if agent_1[remove_point] == 1:
agent_1[remove_point] = 0
sum_sent_in_summary -=1
fitness_1 = compute_fitness(self.title, self.sentences, agent_1, self.simWithTitle, self.simWithDoc,self.sim2sents, self.number_of_nouns, self.order_params)
child_1 = (agent_1, fitness_1, agent_1, velocity, 0, 0)
#tìm điểm chéo 2
crossover_point_2 = 1 + random.randint(0, self.num_objects - 2)
agent_2a = individual_1[0][:crossover_point_2] + individual_2[0][crossover_point_2:]
fitness_2a = compute_fitness(self.title, self.sentences, agent_2a, self.simWithTitle, self.simWithDoc,self.sim2sents, self.number_of_nouns, self.order_params)
agent_2b = individual_2[0][:crossover_point_2] + individual_1[0][crossover_point_2:]
# agent_2 = individual_2[0][:crossover_point] + individual_1[0][crossover_point:]
fitness_2b = compute_fitness(self.title, self.sentences, agent_2b, self.simWithTitle, self.simWithDoc,self.sim2sents, self.number_of_nouns, self.order_params)
if fitness_2a > fitness_2b:
child_2 = (agent_2a, fitness_2a, agent_2a, velocity, 0, 0)
else:
child_2 = (agent_2b, fitness_2b, agent_2b, velocity, 0, 0)
sum_sent_in_summary_2 = sum(child_2[0])
agent_2 = child_2[0]
fitness_2 = child_2[1]
if sum_sent_in_summary_2 > max_sent:
while(sum_sent_in_summary_2 > max_sent):
remove_point = 1 + random.randint(0, self.num_objects - 2)
if agent_2[remove_point] == 1:
agent_2[remove_point] = 0
sum_sent_in_summary_2 -= 1
fitness_2 = compute_fitness(self.title, self.sentences, agent_2, self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
child_2 = (agent_2, fitness_2, agent_2, velocity, 0, 0)
return child_1, child_2
def mutate(self, individual, max_sent):
velocity_vector = individual[3]
pbest_position = individual[2]
sum_sent_in_summary = sum(individual[0])
agent = individual[0][:]
for i in range(len(agent)):
if random.random() < self.mutation_rate and sum_sent_in_summary < max_sent :
if agent[i] == 0 :
agent[i] = 1
sum_sent_in_summary +=1
# else :
# agent[i] = 0
# sum_sent_in_summary -=1
fitness = compute_fitness(self.title, self.sentences, agent, self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
return (agent, fitness, pbest_position, velocity_vector, 0, 0)
def crossover(self, individual_1, individual_2, max_sent):
# check tỷ lệ crossover
if self.num_objects < 2 or random.random() >= self.crossover_rate:
return individual_1[:], individual_2[:]
individual_2 = random.choice(individual_2[:-1])
if len(individual_2) == 0:
fitness1 = compute_fitness(self.title, self.sentences, individual_1[0], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
child1 = (individual_1[0], individual_2, fitness1)
fitness2 = compute_fitness(self.title, self.sentences, individual_1[1], self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
child2 = (individual_1[1], individual_2, fitness2)
return child1, child2
individual_1 = random.choice(individual_1[:-1])
#tìm điểm chéo 1
crossover_point = 1 + random.randint(0, self.num_objects - 2)
agent_1a = individual_1[:crossover_point] + individual_2[crossover_point:]
agent_1a = self.reduce_no_memes(agent_1a, max_sent)
fitness_1a = compute_fitness(self.title, self.sentences, agent_1a, self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
agent_1b = individual_2[:crossover_point] + individual_1[crossover_point:]
agent_1b = self.reduce_no_memes(agent_1b, max_sent)
fitness_1b = compute_fitness(self.title, self.sentences, agent_1b, self.simWithTitle, self.simWithDoc, self.sim2sents, self.number_of_nouns, self.order_params)
if fitness_1a > fitness_1b:
child_1 = (agent_1a, agent_1b, fitness_1a)
else:
child_1 = (agent_1a, agent_1b, fitness_1b)
#tìm điểm chéo 2
crossover_point_2 = 1 + random.randint(0, self.num_objects - 2)
agent_2a = individual_1[:crossover_point_2] + individual_2[crossover_point_2:]
agent_2a = self.reduce_no_memes(agent_2a, max_sent)
fitness_2a = compute_fitness(self.title, self.sentences, agent_2a, self.simWithTitle, self.simWithDoc,self.sim2sents, self.number_of_nouns, self.order_params)
agent_2b = individual_2[:crossover_point_2] + individual_1[crossover_point_2:]
agent_2b = self.reduce_no_memes(agent_2b, max_sent)
fitness_2b = compute_fitness(self.title, self.sentences, agent_2b, self.simWithTitle, self.simWithDoc,self.sim2sents, self.number_of_nouns, self.order_params)
if fitness_2a > fitness_2b:
child_2 = (agent_2a, agent_2b, fitness_2a)
else:
child_2 = (agent_2a, agent_2b, fitness_2b)
return child_1, child_2
def mutate(self, individual, max_sent):
sum_sent_in_summary = sum(individual[0])
agent = individual[0][:]
for i in range(len(agent)):
if random.random(
) < self.mutation_rate and sum_sent_in_summary < max_sent:
if agent[i] == 0:
agent[i] = 1
sum_sent_in_summary += 1
else:
agent[i] = 0
sum_sent_in_summary -= 1
fitness = compute_fitness(self.title, self.sentences, agent,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.simWithAbs, self.rougeforsentences,
self.order_params)
return (agent, fitness)
def generate_population(self, amount):
population = []
for i in range(amount):
agent = np.zeros(self.num_objects)
try:
agent[np.random.choice(list(range(self.num_objects)),
self.num_picked_sents,
replace=False)] = 1
except:
agent[np.random.choice(list(range(self.num_objects)),
self.num_picked_sents,
replace=True)] = 1
print("bug")
agent = agent.tolist()
fitness = compute_fitness(self.title, self.sentences, agent,
self.simWithTitle, self.simWithDoc,
self.sim2sents, self.number_of_nouns,
self.simWithAbs, self.rougeforsentences,
self.order_params)
population.append((agent, fitness))
return population
