def evaluate_function(X, test_points, f_index):
N = len(test_points)
dim = len(test_points[0])
fitness_test_points = np.zeros(N)
# расчет значения функции в центральной точке
fitness_operating_point = test_function.test_function(X, f_index, dim)
for i in range(N):
x_i = test_points[i, :]
fitness_test_points[i] = test_function.test_function(x_i, f_index, dim)
return fitness_test_points, fitness_operating_point
def draw_isolines(low, up, dimension, f_index, delta=0.15):
# delta = 0.15
# для 4 функции 0.05
if (type(up) == int) or (type(up) == float):
x = np.arange(low, up, delta)
y = np.arange(low, up, delta)
else:
x = np.arange(low[0], up[0], delta)
y = np.arange(low[1], up[1], delta)
X, Y = np.meshgrid(x, y)
Z = test_function.test_function(np.array([X, Y]), f_index, dimension)
levels = np.arange(np.min(Z), np.max(Z), delta) # * 65
# CS = plt.contour(X, Y, Z, levels=levels)
# CS = plt.contour(X, Y, Z)
# plt.clabel(CS, fmt="%1.1f", inline=1, fontsize=3)
# plt.title("График изолиний функции F" + str(f_index))
# plt.show()
return X, Y, Z, levels
def evaluate_function(X, f_index):
N = len(X)
dim = len(X[0])
fit = np.zeros(N)
for i in range(N):
x_i = X[i, :]
fit[i] = test_function.test_function(x_i, f_index, dim)
return fit
def optimization(empire, gamma, ProblemParam):
""" Функция оптимизации положения империалиста (столицы).
optization(empire, gamma, ProblemParam) -> empire
Оптимизация осуществляется в небольшой окрестности.
Окрестность (delta) расчитывается как gamma * best,
где gamma - настраеваемый параметр алгоритма (gamma < 1)
best - евклидово расстояние до ближайшей колонии.
В случае, если у империалиста отсутствуют колонии область поиска определяется как gamma * gamma.
Потенциальная позиция для перемещения выбирается случаынйм образом в данной окрестности:
potential_position[i] = empire.imperialist_position[i] + np.random.uniform(-1, 1) * delta.
Пригодность потенциального положения определяется путем расчета значения функции качества в этой точке,
если оно [значение функции качества] меньше значения функции качества в текущей точке
происходит передвижение империалиста, в противном случае империалист не перемещается.
--------------------------------------------------------
Параметры:
@param empire - объект класса "Empires",
необходимы поля - imperialist_position, colonies_position и imperialist_fitness
@param gamma - настраеваемый параметр алгоритма (0 < gamma < 1), число.
@param ProblemParam - объект класса "ProblemParams"
Возвращаемые значения:
@return empire - объект класса "Empires"
"""
num_colonies = len(empire.colonies_position)
if num_colonies == 0:
best = gamma
# поиск самой ближайшей колонии
for i in range(num_colonies):
distance_vector = empire.imperialist_position - empire.colonies_position[
i]
distance = np.linalg.norm(distance_vector)
if i == 0:
best = distance
if best > distance:
best = distance
# Определение радиуса поисковой области
delta = gamma * best
potential_position = np.zeros(len(empire.imperialist_position))
for i in range(len(empire.imperialist_position)):
potential_position[i] = empire.imperialist_position[
i] + np.random.uniform(-1, 1) * delta
potential_fit = test_function.test_function(
potential_position, ProblemParam.test_function_index,
ProblemParam.dimention)
if potential_fit < empire.imperialist_fitness:
empire.imperialist_position = potential_position
empire.imperialist_fitness = potential_fit
return empire
def data_gen_for_3d_func(max_iter, coord, f_index, dimension, num=0):
while num < max_iter:
# не работает если написать так np.zeros((len(coord[num]), 1))
xlist = np.zeros((len(coord[num]), ))
ylist = np.zeros((len(coord[num]), ))
zlist = np.zeros((len(coord[num]), ))
for j in range(len(coord[num])):
xlist[j] = coord[num][j][0]
ylist[j] = coord[num][j][1]
zlist[j] = test_function.test_function(coord[num][j], f_index,
dimension)
num = num + 1
yield xlist, ylist, zlist
def get_data(delta, low, up, f_index, dimension):
if (type(up) == int) or (type(up) == float):
x = np.arange(low, up, delta)
y = np.arange(low, up, delta)
else:
x = np.arange(low[0], up[0], delta)
y = np.arange(low[1], up[1], delta)
X, Y = np.meshgrid(x, y)
Z = test_function.test_function(np.array([X, Y]), f_index, dimension)
return X, Y, Z
def optimization(f_index, min_flag):
print("Запущен алгоритм селективного усреднения координат...")
func_best_SAC, agent_best_SAC, best_chart_SAC = run_SAC(f_index, min_flag)
print("Запущен алгоритм гравитационного поиска...")
func_best_GSA, agent_best_GSA, best_chart_GSA = run_GSA(f_index, min_flag)
print("Запущен империалистический конкурентный алгоритм...")
func_best_ICA, agent_best_ICA, best_chart_ICA = run_ICA(f_index, min_flag)
func_best = np.array([func_best_SAC, func_best_GSA, func_best_ICA])
agent_best = np.array([agent_best_SAC, agent_best_GSA, agent_best_ICA])
comparative_graph_convergence(f_index,
SAC=best_chart_SAC,
GSA=best_chart_GSA,
ICA=best_chart_ICA)
grahp_isolines(f_index)
# print(str(func_best))
# print(str(agent_best))
# func_best, agent_best, best_chart, mean_chart, coord_x, stop_iteration, last_value_func, coord_x_test = result_SAC
# func_best, agent_best, best_chart, mean_chart, coord = result_GSA
# func_best, agent_best, best_chart, mean_chart, coord_x, stop_iteration = result_ICA
low, up, dim = get_range(f_index)
while len(func_best) > 1:
min_fit = np.min(func_best)
arg_min = np.argmin(func_best)
if np.all(agent_best[arg_min] > low) and np.all(
agent_best[arg_min] < up):
min_test = test_function.test_function(agent_best[arg_min],
f_index, dim)
if min_test <= min_fit:
print("Лучший результат: " + str(min_test))
print("Лучшая точка: " + str(agent_best[arg_min]))
if arg_min == 0:
print("Алгоритм селективного усреднения")
elif arg_min == 1:
print("Алгоритм гравитационного поиска")
elif arg_min == 2:
print("Империалистический конкурентный алгоритм")
break
else:
func_best = np.delete(func_best, [arg_min])
agent_best = np.delete(agent_best, [arg_min])
print("Работа завершена.")
def ICA(ProblemParam, AlgorithmParam, max_iter, min_flag, epsilon):
low, up, dimension = test_function_range.get_range(
ProblemParam.test_function_index)
min_limit, max_limit, search_space_size = modifying_size_search_space(
low, up, dimension)
ProblemParam.max_limit_search = max_limit
ProblemParam.min_limit_search = min_limit
ProblemParam.search_space_size = search_space_size
num_of_all_colonies = AlgorithmParam.num_of_countries - AlgorithmParam.num_of_initial_imperialists
coord = np.empty((max_iter, AlgorithmParam.num_of_countries, dimension))
# ----------Создание первоначальных империй----------
initial_сountries = generate_new_country(AlgorithmParam.num_of_countries,
min_limit, max_limit)
# расчет приспособленности (стоимости) каждой страны
initial_fitness_country = np.zeros(AlgorithmParam.num_of_countries)
for i in range(AlgorithmParam.num_of_countries):
initial_fitness_country[i] = test_function.test_function(
initial_сountries[i], ProblemParam.test_function_index, dimension)
# сортировка по убыванию
ind_fitness_country = np.argsort(initial_fitness_country)[::-1]
initial_fitness_country = np.sort(initial_fitness_country)[::-1]
# initial_сountries = np.take(initial_сountries, ind_fitness_country, axis=0)
initial_сountries_t = np.array([
initial_сountries[ind_fitness_country[i]]
for i in range(len(ind_fitness_country))
])
initial_сountries = initial_сountries_t
empires = create_initial_empires(initial_сountries,
initial_fitness_country, ProblemParam,
AlgorithmParam)
# ---------------------------------------------------
# Главный цикл алгоритма
min_fitness = np.zeros((max_iter, ))
mean_fitness = np.zeros((max_iter, ))
# best_chart = np.zeros(max_iter)
# mean_chart = np.zeros(max_iter)
best_chart = []
mean_chart = []
coord_x = np.zeros((max_iter, 1, dimension))
stop_iteration = max_iter
for i in range(max_iter):
iteration = i + 1
AlgorithmParam.revolution_rate = AlgorithmParam.revolution_rate * AlgorithmParam.damp_ratio
remained = max_iter - iteration
imperialist_fit = np.zeros(len(empires))
for j in range(len(empires)):
imperialist_fit[j] = empires[j].imperialist_fitness
best = np.min(imperialist_fit)
best_x = np.argmin(imperialist_fit)
if iteration == 1:
# лучшее значение функции
func_best = best
# лучший агент
agent_best = empires[best_x].imperialist_position
if best < func_best:
func_best = best
agent_best = empires[best_x].imperialist_position
best_chart.append(func_best)
coord_x[i][0] = agent_best
mean_chart.append(np.mean(imperialist_fit))
for j in range(len(empires)):
empires[j] = optimization(empires[j], 0.1, ProblemParam)
# Ассимиляция. Движение колоний к империалистам
empires[j] = assimilate_colonies(empires[j], ProblemParam,
AlgorithmParam)
# Революция
empires[j] = revolve_colonies(empires[j], ProblemParam,
AlgorithmParam)
# Расчет новой стоимости стран (приспособленности)
fit = np.zeros(len(empires[j].colonies_position))
for k in range(len(empires[j].colonies_position)):
x_i = empires[j].colonies_position[k]
fit[k] = test_function.test_function(
x_i, ProblemParam.test_function_index, dimension)
empires[j].colonies_fitness = fit
empires[j] = prosses_empire(empires[j])
# Вычисление общей стоимости (приспособленности) империи
if empires[j].colonies_fitness.size == 0:
empires[j].total_fitness = empires[j].imperialist_fitness
else:
empires[j].total_fitness = empires[
j].imperialist_fitness + AlgorithmParam.zeta * np.mean(
empires[j].colonies_fitness)
# слияние империй
empires = unite_simular_empires(empires, ProblemParam, AlgorithmParam)
# империалистическая конкуренция
empires = imperialistic_competition(empires)
if (len(empires) == 1) and (AlgorithmParam.stop_if_just_one_empire):
break
# if iteration > 11:
# break_point = check_break(best_chart, epsilon)
# if break_point:
# stop_iteration = iteration
# break
return func_best, agent_best, best_chart, mean_chart, coord_x, stop_iteration
def create_initial_empires(initial_сountries, initial_fitness_country,
ProblemParam, AlgorithmParam):
"""
Функция инициализации империй (точек с лучшим значенийм функции качества (стоимостью)).
Параметры:
:param initial_сountries: Набор координат стран, составленный в порядке убывания их значения функции качества.
Двумерный массив.
:type initial_сountries: numpy.array
:param initial_fitness_country: Набор значений функции качетва (стоимостей) стран,
отсортированный в порядке убывания. Одномерный массив-строка.
:type initial_fitness_country: numpy.array
:param ProblemParam: Объект хранящий параметры задачи оптимизации. Объект класса ProblemParams.
Имеет поля:
dimention: Размерность (количество переменных) целевой функции типа int.
min_limit_search: Нижняя граница области поиска экстремума. Одномерный массив-строка типа numpy.array.
max_limit_search: Верхняя граница области поиска экстремума. Одномерный массив-строка типа numpy.array.
test_function_index: Номер тестовой функции из файла test_function.
search_space_size: Размер области поиска экстремума. Одномерный массив-строка типа numpy.array.
:type ProblemParam: ProblemParams
:param AlgorithmParam: Объект хранящий параметры алгоритма. Объект класса AlgorithmParams.
Имеет поля:
num_of_initial_imperialists: Изначальное количество империалистов, целое число.
num_of_countries: Количество стран, целое число.
zeta: Коэффициент для расчета общей ценности империи,
характеризует влияние стоимостей колоний на общую стоимость империи.
revolution_rate: ?????
damp_ratio: Процент колиний подвернувшихся революции.
assimilation_coefficient: Коэффициент ассимиляции,
характеризует процент максимально возможного шага колонии за одну итерацию.
stop_if_just_one_empire: True - алгоритм можно завершить если останеться только один империалист,
False - иначе.
uniting_threshold: Величина расстояния между двумя империалистами
при которой произойдет слияние их империй.
:type AlgorithmParam: AlgorithmParams
:return empires: Список хрянящий объекты класса Empires.
"""
num_all_colonies = AlgorithmParam.num_of_countries - AlgorithmParam.num_of_initial_imperialists
num_init_imper = AlgorithmParam.num_of_initial_imperialists
all_imperialists_position = initial_сountries[:num_init_imper]
all_imperialists_fitness = initial_fitness_country[:num_init_imper]
all_colonies_position = initial_сountries[num_init_imper:]
all_colonies_fitness = initial_fitness_country[num_init_imper:]
if np.max(all_imperialists_fitness) > 0:
all_imperialists_power = 1.3 * np.max(
all_imperialists_fitness) - all_imperialists_fitness
else:
all_imperialists_power = 0.7 * np.max(
all_imperialists_fitness) - all_imperialists_fitness
power_norm = all_imperialists_power / np.sum(all_imperialists_power)
all_imperialists_num_colonies = np.round(power_norm * num_all_colonies)
# последнее значение это число всех стран за минусом уже распределенных
all_imperialists_num_colonies[-1] = num_all_colonies - np.sum(
all_imperialists_num_colonies[:-1])
random_index = np.random.permutation(num_all_colonies)
empires = []
for i in range(AlgorithmParam.num_of_initial_imperialists):
imp_pos = all_imperialists_position[i]
imp_fit = all_imperialists_fitness[i]
rand = random_index[:int(all_imperialists_num_colonies[i])]
colonies_pos = all_colonies_position[rand]
colonies_fit = all_colonies_fitness[rand]
total_fit = imp_fit + AlgorithmParam.zeta * np.mean(colonies_fit)
Empire = Empires.Empires(imp_pos, imp_fit, colonies_pos, colonies_fit,
total_fit)
empires.append(Empire)
for i in range(len(empires)):
if len(empires[i].colonies_position) == 0:
empires[i].colonies_position = generate_new_country(
1, ProblemParam.min_limit_search,
ProblemParam.max_limit_search)
empires[i].colonies_fitness = [
test_function.test_function(empires[i].colonies_position[0],
ProblemParam.test_function_index,
ProblemParam.dimention)
]
return empires