def grahp_isolines(f_index):
low, up, dim = test_function_range.get_range(f_index)
# точечный анимированный график для трехмерных функций
if dim == 2:
fig, ax = plt.subplots()
# xdata, ydata = [], []
# line, = ax.plot([], [], lw=2, color='b', linestyle=' ', marker='o', label='Агенты')
plt.legend(loc='upper left')
params = {
'legend.fontsize': 'x-large',
'figure.figsize': (15, 5),
'axes.labelsize': 'large',
'axes.titlesize': 'large',
'xtick.labelsize': 'large',
'ytick.labelsize': 'large'
}
plt.rcParams.update(params)
X, Y, Z, levels = draw_isolines(low, up, dim, f_index, delta=0.1)
# рисование графика изолиний исходной функции
CS = plt.contour(X, Y, Z, levels=levels)
name = "Функция F" + str(f_index)
plt.title(name, loc='center', fontsize=18)
ax.grid()
# создание анимированного точечного графика
# blit контролирует используется ли blitting. Если True не будет работать масштабирование и перемещение графика
# ani = animation.FuncAnimation(fig, run, frames=data_gen(max_iter, coord), blit=False,
# interval=rate_change_graph, repeat=False,
# init_func=make_init(low, up, xdata, ydata, line, ax), fargs=(line,))
plt.show()
def run_ICA(f_index, min_flag):
num_of_countries = 200 # общее количество стран
num_of_initial_imperialists = 10 # начальное количество империалистов
revolution_rate = 0.3
assimilation_coefficient = 2 # коэффициент ассимиляции "beta"
assimilation_angle_coefficient = 0.5 # угловой коэффициент ассимиляции "gama"
zeta = 0.02
damp_ratio = 0.99
stop_if_just_one_empire = False
uniting_threshold = 0.02
max_iter = 600
epsilon = pow(10, -15)
low, up, dim = get_range(f_index)
ProblemParam = ProblemParams(dim, low, up, f_index, 0)
AlgorithmParam = AlgorithmParams(num_of_countries,
num_of_initial_imperialists, zeta,
revolution_rate, damp_ratio,
assimilation_coefficient,
stop_if_just_one_empire,
uniting_threshold)
res = ICA(ProblemParam, AlgorithmParam, max_iter, min_flag, epsilon)
func_best, agent_best, best_chart, mean_chart, coord_x, stop_iteration = res
return func_best, agent_best, best_chart
def print_graph(f_index, rate_change_graph, coord, max_iter):
low, up, dim = test_function_range.get_range(f_index)
# точечный анимированный график для трехмерных функций
if dim == 2:
fig, ax = plt.subplots()
xdata, ydata = [], []
line, = ax.plot([], [],
lw=2,
color='b',
linestyle=' ',
marker='o',
label='Агенты')
plt.legend(loc='upper left')
X, Y, Z, levels = draw_isolines(low, up, dim, f_index)
# рисование графика изолиний исходной функции
CS = plt.contour(X, Y, Z, levels=levels)
ax.grid()
# создание анимированного точечного графика
# blit контролирует используется ли blitting. Если True не будет работать масштабирование и перемещение графика
ani = animation.FuncAnimation(fig,
run,
frames=data_gen(max_iter, coord),
blit=False,
interval=rate_change_graph,
repeat=False,
init_func=make_init(
low, up, xdata, ydata, line, ax),
fargs=(line, ))
plt.show()
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 main():
num_of_countries = 200 # общее количество стран
num_of_initial_imperialists = 10 # начальное количество империалистов
revolution_rate = 0.3
assimilation_coefficient = 2 # коэффициент ассимиляции "beta"
assimilation_angle_coefficient = 0.5 # угловой коэффициент ассимиляции "gama"
zeta = 0.02
damp_ratio = 0.99
stop_if_just_one_empire = False
uniting_threshold = 0.02
zarib = 1.05
alpha = 0.1
epsilon = pow(10, -20)
max_iter = 100
min_flag = 1 # 1 - минимизация, 0 - максимизация
# скорость изменения графика, установите значение в милисекундах
rate_change_graph = 500
# индекс функции в файле test_function
f_index = 10
low, up, dim = test_function_range.get_range(f_index)
ProblemParam = ProblemParams.ProblemParams(dim, low, up, f_index, 0)
AlgorithmParam = AlgorithmParams.AlgorithmParams(
num_of_countries, num_of_initial_imperialists, zeta, revolution_rate,
damp_ratio, assimilation_coefficient, stop_if_just_one_empire,
uniting_threshold)
print("Подождите идут вычисления...")
func_best, agent_best, best_chart, mean_chart, coord_x, stop_iteration = ICA(
ProblemParam, AlgorithmParam, max_iter, min_flag, epsilon)
print("-------------------------------")
print("Лучший результат: " + str(func_best))
print("Лучшее решение (точка, агент): " + str(agent_best))
print("Лучшие решения на каждой итерации: " + str(best_chart))
print("Среднее решений на каждой итерации: " + str(mean_chart))
print("-------------------------------")
graph.graph_motion_points_3d(f_index, rate_change_graph, coord_x, max_iter)
graph.graph_best_chart(best_chart)
graph.print_graph(f_index, rate_change_graph, coord_x, max_iter)
def graph_motion_points_3d(f_index, rate_change_graph, coord, max_iter):
low, up, dim = test_function_range.get_range(f_index)
fig = plt.figure()
# ax = Axes3D(fig)
ax = fig.add_subplot(111, projection='3d')
# ax = fig.gca(projection='3d')
xdata, ydata, zdata = [], [], []
# line, = ax.scatter([], [], [], lw=2, color='b', marker='o', label='Агенты') # linestyle='-'
# line, = ax.scatter([], [], [], marker='o')
# line, = ax.plot([], [], [], linestyle="", marker="o", color='b')
line = ax.scatter([], [], [], marker='o', color='r', label='Агенты')
plt.legend(loc='upper left')
# получение данных для рисования фона
X, Y, Z = get_data_func_3d(f_index, delta=0.1)
# рисование 3D графика исходной функции как фон
# plot_surface - сплошная поверхность с подсветкой высот, contour3D - сетка с подсветкой высот (изолинии)
# plot_wireframe - сетка одного цвета
ax.plot_surface(X, Y, Z, rstride=4, cstride=4, cmap=cm.jet, alpha=0.5)
ax.grid()
# создание анимированного точечного графика
# blit контролирует используется ли blitting. Если True не будет работать масштабирование и перемещение графика
ani = animation.FuncAnimation(
fig,
run_3d,
frames=data_gen_for_3d_func(max_iter, coord, f_index, dim),
blit=False,
interval=rate_change_graph,
repeat=False,
init_func=make_init_3d(low, up, xdata, ydata, zdata, ax, line),
fargs=(line, ax))
plt.show()
def get_data_func_3d(f_index, delta=0.2):
low, up, dim = test_function_range.get_range(f_index)
X, Y, Z = get_data(delta, low, up, f_index, dim)
return X, Y, Z
def SAC(f_index, max_iter, N, min_flag, nuclear_func_index, selectivity_factor,
gamma, q, epsilon):
low, up, dimension = test_function_range.get_range(f_index)
stop_iteration = max_iter
best_chart = []
mean_chart = []
coord_x = 0
coord_x_test = 0
if dimension == 2:
# массив для сохранения прогресса координат решений
coord_x = np.empty((max_iter, 1, dimension))
coord_x_test = np.empty((max_iter, N, dimension))
X = initialization_X_0(low, up, dimension)
delta_X_0 = np.array([(up - low) / 2])
# delta_X = np.zeros((dimension, ))
delta_X = delta_X_0
for i in range(max_iter):
iteration = i + 1
if iteration == 1:
test_points = initialization_test_points(N, dimension, delta_X_0,
X)
fitness_test_points, fitness_operating_point = evaluate_function(
X, test_points, f_index)
else:
test_points = initialization_test_points(N, dimension, delta_X, X)
fitness_test_points, fitness_operating_point = evaluate_function(
X, test_points, f_index)
if dimension == 2:
coord_x[i] = X.copy()
coord_x_test[i] = test_points.copy()
if min_flag == 1:
# лучшее решение
best = np.min(fitness_test_points)
# лучшее положение (точка, агент)
best_x = np.argmin(fitness_test_points)
else:
best = np.max(fitness_test_points)
best_x = np.argmax(fitness_test_points)
if iteration == 1:
# лучшее значение функции
func_best = best
# лучший агент
agent_best = test_points[best_x, :]
if min_flag == 1:
# минимизация
if best < func_best:
func_best = best
agent_best = test_points[best_x, :]
else:
# максимизация
if best > func_best:
func_best = best
agent_best = test_points[best_x, :]
# сохранение лучших и средних решений на итерации
# best_chart.append(func_best)
best_chart.append(fitness_operating_point)
mean_chart.append(np.mean(fitness_test_points))
g = find_g(test_points, fitness_test_points, min_flag)
nuclear_func = nuclear_function_K(g, nuclear_func_index,
selectivity_factor)
X, delta_X = move(delta_X, X, test_points, nuclear_func, q)
# delta_X = size_area_search_calculation(delta_X, gamma, q, nuclear_func, N)
last_value_func = fitness_operating_point
# if iteration > 2:
# break_point = break_check(best_chart, epsilon, delta_X)
# if break_point:
# stop_iteration = iteration
# break
return func_best, agent_best, best_chart, mean_chart, coord_x, stop_iteration, last_value_func, coord_x_test
def GSA(f_index, N, max_iter, elitist_check, min_flag, r_power):
r_norm = 2
low, up, dimension = test_function_range.get_range(f_index)
# if dimension == 2:
# массив для сохранения прогресса координат решений
coord = np.empty((max_iter, N, dimension))
X = initialization(dimension, N, up, low)
velocity = np.zeros((N, dimension))
best_chart = []
mean_chart = []
for i in range(max_iter):
iteration = i + 1
# print("Началась " + str(iteration) + " итерация алгоритма.")
# проверка выхода за границы поиска
X = space_bound(X, up, low)
# расчет значений функции качества (минимизируемой или максимизируемой функции)
fit = evaluate_function(X, f_index)
if dimension == 2:
coord[i] = X.copy()
if min_flag == 1:
# лучшее решение
best = np.min(fit)
# лучшее положение (точка, агент)
best_x = np.argmin(fit)
else:
best = np.max(fit)
best_x = np.argmax(fit)
if iteration == 1:
# лучшее значение функции
func_best = best
# лучший агент
agent_best = X[best_x, :]
if min_flag == 1:
# минимизация
if best < func_best:
func_best = best
agent_best = X[best_x, :]
else:
# максимизация
if best > func_best:
func_best = best
agent_best = X[best_x, :]
# сохранение лучших и средних решений на итерации
best_chart.append(func_best)
mean_chart.append(np.mean(fit))
# расчет масс, гравитационной постоянной, ускорения
mass = mass_calculation(fit, min_flag)
G = G_constant(iteration, max_iter)
a = acceleration_calc(X, mass, G, r_norm, r_power, elitist_check, iteration, max_iter)
# расчет скорости и нового положения
X, velocity = move(X, a, velocity)
return func_best, agent_best, best_chart, mean_chart, coord
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