def next_generation_MGG(data, solutions, bias, num_parents, num_children,
num_elite_preservation, num_dimentions):
parents, parents_index = functions.random_parent(data, num_parents)
#print(parents_index)
'''
for index in range(len(parents_index)):
count = 0
for index2 in range(index):
if parents_index[index2] < parents_index[index]:
count += 1
del data[parents_index[index] - count]
'''
children = np.zeros((num_children + num_parents, num_dimentions))
for parent_index in range(len(parents)):
children[parent_index] = np.copy(parents[parent_index])
#print(children)
for cross in range(num_children):
child_vector = crossover(parents, num_parents, num_dimentions)
children[num_parents + cross] = np.copy(child_vector)
#print(children)
evaluations = functions.get_evaluations_list(children, solutions, bias)
rank_list = functions.get_ranking_list(evaluations)
# print(rank_list)
# print(evaluations)
'''
# 上位のものを元のリストに戻す
for order in range(1, num_elite_preservation + 1):
for index in range(len(rank_list)):
if rank_list[index] == order:
data[parents_index[order-1]] = np.copy(children[index])
break
# print(functions.get_evaluations_list(children, solutions, bias))
# ルーレット選択により選ばれた個体を一つ戻す
selected = functions.choose_roulette(children, (num_parents - num_elite_preservation), solutions, bias)
for element in range(len(selected)):
data[parents_index[num_elite_preservation + element]] = np.copy(selected[element])
'''
min_index1 = np.argmin(evaluations[0:4])
data[parents_index[0]] = np.copy(children[min_index1])
min_index2 = np.argmin(evaluations[4:8]) + 4
data[parents_index[1]] = np.copy(children[min_index2])
min_index3 = np.argmin(evaluations[8:12]) + 8
data[parents_index[2]] = np.copy(children[min_index3])
min_index4 = np.argmin(evaluations[12:16]) + 12
data[parents_index[3]] = np.copy(children[min_index4])
return data
def take_top_100(data, evaluations, ranking_list, solutions, bias):
new_data = []
new_ranking = []
for element in range(len(data)):
if ranking_list[element] <= 100:
new_data.append(data[element])
new_ranking.append(ranking_list[element])
new_evaluations = functions.get_evaluations_list(new_data, solutions, bias)
return new_data, new_evaluations, new_ranking
def next_generation_MGG_improve(data, solutions, bias, num_parents, num_children, num_elite_preservation, num_dimentions):
new_generation = np.zeros((len(data), num_dimentions))
turn = 0
while len(data) != 0:
parents, parents_index = functions.random_parent(data, num_parents)
for index in range(len(parents_index)):
count = 0
for index2 in range(index):
if parents_index[index2] < parents_index[index]:
count += 1
data = np.delete(data, parents_index[index] - count, axis=0)
# del data[parents_index[index] - count]
children = np.zeros((num_children + num_parents, num_dimentions))
for parent_index in range(len(parents)):
children[parent_index] = np.copy(parents[parent_index])
for cross in range(num_children):
child_vector = crossover(parents, num_parents, num_dimentions)
children[num_parents + cross] = np.copy(child_vector)
evaluations = functions.get_evaluations_list(children, solutions, bias)
rank_list = functions.get_ranking_list(evaluations)
# 上位のものを元のリストに戻す
for order in range(1, num_elite_preservation + 1):
for index in range(len(rank_list)):
if rank_list[index] == order:
new_generation[turn * num_parents + order - 1] = np.copy(children[index])
break
# ルーレット選択により選ばれた個体を一つ戻す
selected = functions.choose_roulette(children, (num_parents - num_elite_preservation), solutions, bias)
for element in range(len(selected)):
new_generation[turn * num_parents + num_elite_preservation + element] = np.copy(selected[element])
min_index1 = np.argmin(evaluations[0:4])
new_generation[turn * num_parents] = np.copy(children[min_index1])
min_index2 = np.argmin(evaluations[4:8]) + 4
new_generation[turn * num_parents] = np.copy(children[min_index2])
'''
min_index3 = np.argmin(evaluations[8:12]) + 8
new_generation[turn * num_parents] = np.copy(children[min_index3])
min_index4 = np.argmin(evaluations[12:16]) + 12
new_generation[turn * num_parents] = np.copy(children[min_index4])
'''
turn += 1
return new_generation
def next_generation_JGG(data, solutions, bias, num_parents, num_children,
num_dimentions):
new_generation = np.zeros((len(data), num_dimentions))
turn = 0
while len(data) != 0:
parents, parents_index = functions.random_parent(data, num_parents)
for index in range(len(parents_index)):
count = 0
for index2 in range(index):
if parents_index[index2] < parents_index[index]:
count += 1
data = np.delete(data, parents_index[index] - count, axis=0)
# del data[parents_index[index] - count]
children = np.zeros((num_children, num_dimentions))
for cross in range(num_children):
child_vector = crossover(parents, num_parents, num_dimentions)
children[cross] = np.copy(child_vector)
# children.append(child_vector)
evaluations = np.array(
functions.get_evaluations_list(children, solutions, bias))
rank_list = np.array(functions.get_ranking_list(evaluations))
'''
# 上位のものを元のリストに戻す
for order in range(1, num_parents+1):
for index in range(len(rank_list)):
if rank_list[index] == order:
new_generation[turn * num_parents + order - 1] = np.copy(children[index])
# new_generation.append(children[index])
# del children[index]
# del rank_list[index]
break
'''
min_index1 = np.argmin(evaluations[0:4])
new_generation[turn * num_parents] = np.copy(children[min_index1])
min_index2 = np.argmin(evaluations[4:8]) + 4
new_generation[turn * num_parents + 1] = np.copy(children[min_index2])
'''
min_index3 = np.argmin(evaluations[8:12]) + 8
new_generation[turn * num_parents + 2] = np.copy(children[min_index3])
min_index4 = np.argmin(evaluations[12:16]) + 12
new_generation[turn * num_parents + 3] = np.copy(children[min_index4])
'''
turn += 1
return new_generation
def make_children(data, num_parents, elite_preservation_rate, solutions, bias):
children = []
evaluations = functions.get_evaluations_list(data, solutions, bias)
rank_list = functions.get_ranking_list(evaluations)
# エリート保存分
for order in range(1, int(elite_preservation_rate * len(data) + 1)):
for index in range(len(rank_list)):
if rank_list[index] == order:
children.append(data[index])
break
for element in range(len(data) - int(len(data) * elite_preservation_rate)):
children.append(crossover(data, num_parents, solutions, bias))
return children
def next_generation_JGG(data, solutions, bias, num_parents, num_children, num_dimentions):
parents, parents_index = functions.random_parent(data, num_parents)
'''
for index in range(len(parents_index)):
count = 0
for index2 in range(index):
if parents_index[index2] < parents_index[index]:
count += 1
del data[parents_index[index] - count]
'''
children = np.zeros((num_children, num_dimentions))
for cross in range(num_children):
child_vector = crossover(parents, num_parents, num_dimentions)
children[cross] = np.copy(child_vector)
evaluations = functions.get_evaluations_list(children, solutions, bias)
rank_list = functions.get_ranking_list(evaluations)
'''
# 上位のものを元のリストに戻す
for order in range(1, num_parents+1):
for index in range(len(rank_list)):
if rank_list[index] == order:
data[parents_index[order-1]] = np.copy(children[index])
break
'''
min_index1 = np.argmin(evaluations[0:4])
data[parents_index[0]] = np.copy(children[min_index1])
min_index2 = np.argmin(evaluations[4:8]) + 4
data[parents_index[1]] = np.copy(children[min_index2])
'''
min_index3 = np.argmin(evaluations[8:12]) + 8
data[parents_index[2]] = np.copy(children[min_index3])
min_index4 = np.argmin(evaluations[12:16]) + 12
data[parents_index[3]] = np.copy(children[min_index4])
'''
return data
# 局所解とバイアスに分ける
solutions, bias = functions.divide_solutions_bias(solutions_data)
# 評価値の結果のリスト
evaluations_result = []
for num_experiment in range(1, 101):
print(num_experiment)
# 対象のデータの読み込み
data = functions.read_csv(read_filename)
del data[0]
data = functions.transform_to_float(data)
# before_index = functions.get_result(data, functions.get_evaluations_list(data, solutions, bias), num_experiment, functions.get_best_solution_index(bias), solutions)[2]
# 次の世代の作成
for num in range(num_execute):
# print('-------')
# print(functions.get_evaluation_value(data[before_index], solutions, bias))
data = next_generation_MGG_improve(data, solutions, bias, num_parents, num_children, num_elite_preservation, num_dimentions)
# print(functions.get_result(data, functions.get_evaluations_list(data, solutions, bias), num_experiment, functions.get_best_solution_index(bias), solutions))
# before_index = functions.get_result(data, functions.get_evaluations_list(data, solutions, bias), num_experiment, functions.get_best_solution_index(bias), solutions)[2]
# 新しい世代をcsvに書き込む
functions.write_csv(write_filename + '_%i' % num_experiment, data)
evaluations = functions.get_evaluations_list(data, solutions, bias)
evaluation_vector = functions.get_result(data, evaluations, num_experiment, functions.get_best_solution_index(bias), solutions)
evaluations_result.append(evaluation_vector)
final_result = functions.get_final_result(evaluations_result)
functions.write_result(result_file, evaluations_result, final_result)
# 局所解ファイルの読み込み
solutions_data = functions.read_csv(solutions_file)
del solutions_data[0]
solutions_data = functions.transform_to_float(solutions_data)
# 局所解とバイアスに分ける
solutions, bias = functions.divide_solutions_bias(solutions_data)
solutions = np.array(solutions)
bias = np.array(bias)
evaluations_result = []
for num_experiment in range(1, 101):
print(num_experiment)
random = make_random_matrix(5000, 100)
# 評価値の結果のリスト
evaluations = functions.get_evaluations_list(random, solutions, bias)
rankings = functions.get_ranking_list(evaluations)
matrix100, evaluations100, rankings100 = take_top_100(
random, evaluations, rankings, solutions, bias)
evaluation_vector = functions.get_result(
matrix100, evaluations100, num_experiment,
functions.get_best_solution_index(bias), solutions)
evaluations_result.append(evaluation_vector)
final_result = functions.get_final_result(evaluations_result)
functions.write_result(result_file, evaluations_result, final_result)
