def __init__(self, n_points=50, dimension=2, function_id=1, max_evaluations=10000, verbose=False, plot=0, fig_dir=None): print('\nACOR: Solving F%d in %dD with population size %d...\n' % (function_id, dimension, n_points)) from optproblems.cec2005 import CEC2005 from boundary import Boundary self.n_points = n_points self.dimension = dimension self.function_id = function_id - 1 self.function = CEC2005(dimension)[self.function_id].objective_function self.max_bounds = Boundary(dimension, self.function_id).max_bounds self.min_bounds = Boundary(dimension, self.function_id).min_bounds # Termination parameters self.FE = 0 self.iteration = 0 self.max_evaluations = max_evaluations * dimension self.termination_error = 1e-08 self.should_terminate = False self.optimal_position = CEC2005(dimension)[ self.function_id].get_optimal_solutions()[0].phenome self.optimal_fitness = self.function(self.optimal_position) self.best_position = np.zeros_like(self.optimal_position) self.best_fitness = np.inf self.verbose = verbose self.plot = plot self.fig_config = { 'fig_dir': fig_dir, 'angle': 240, 'xlim': [self.min_bounds[0], self.max_bounds[0]], 'ylim': [self.min_bounds[1], self.max_bounds[1]], 'optimal': self.optimal_position } self.algo = ACOR(self.obj, self.dimension, min_bounds=self.min_bounds, max_bounds=self.max_bounds, ants_num=2, archive_size=self.n_points, q=1e-4, xi=0.85) if self.plot > 0: error = self.best_fitness - self.optimal_fitness fig_name = ('F%d_%d.png' % (self.function_id + 1, self.iteration)) self.fig_config['fig_title'] = ( 'F%d, FE=%d, error=%.2e' % (self.function_id + 1, self.FE, error)) draw_quiver(self.algo, self.function, fig_name, **self.fig_config)
def find_optimal_solution(self): dimension = self.dimension function_id = self.function_id optimal_solutions = CEC2005( dimension)[function_id].get_optimal_solutions() test_prob = Problem(CEC2005(dimension)[function_id].objective_function) test_prob.batch_evaluate(optimal_solutions) return min(optimal_solutions, key=attrgetter('objective_values'))
def draw_original_contour(function_id, **kwargs): dim = 2 func = CEC2005(dim)[function_id] population = kwargs.get('population', []) angle = kwargs.get('angle', 240) rotate = kwargs.get('rotate', False) fig_name = kwargs.get('fig_name', None) fig_title = kwargs.get('fig_title', str(func)) cmap = cm.coolwarm scatter_cmap = cm.jet(np.linspace(0.1, 0.9, len(population))) boundary = Boundary(dim, function_id) step = (boundary.max_bounds[0] - boundary.min_bounds[0]) / 100 X = np.arange(boundary.min_bounds[0], boundary.max_bounds[0] + step, step) Y = np.arange(boundary.min_bounds[1], boundary.max_bounds[1] + step, step) (X, Y) = np.meshgrid(X, Y) positions = (lambda .0: continue[ [ x, y] for (x, y) in .0 ])(zip(X.ravel(), Y.ravel())) solutions = (lambda .0: continue[ Individual(position) for position in .0 ])(positions) problem = Problem(func.objective_function) problem.batch_evaluate(solutions) Z = np.array((lambda .0: continue[ solution.objective_values for solution in .0 ])(solutions)) vmin = min(Z) vmax = max(Z) vmin = vmin - (vmax - vmin) * 0.2 vmax = vmax + (vmax - vmin) * 0.2 Z = Z.reshape(X.shape) inch_size = 4 fig_w = 1 fig_h = 1 fig = plt.figure(figsize = (fig_w * inch_size, fig_h * inch_size)) ax = fig.add_subplot(fig_h, fig_w, 1) ax.set_xlim([ boundary.min_bounds[0], boundary.max_bounds[0]]) ax.set_ylim([ boundary.min_bounds[1], boundary.max_bounds[1]]) cset = ax.contourf(X, Y, Z, cmap = cmap, vmin = vmin, vmax = vmax) fig.colorbar(cset, aspect = 20) colors = iter(scatter_cmap) color = next(colors) x = np.array((lambda .0: continue[ individual.phenome[0] for individual in .0 ])(population)) y = np.array((lambda .0: continue[ individual.phenome[1] for individual in .0 ])(population)) ax.scatter(x, y, color = color, marker = 'o', s = 10) for opt in func.get_optimal_solutions(): optimal_pos = opt.phenome ax.scatter(optimal_pos[0], optimal_pos[1], color = 'w', marker = 'x', s = 100) fig.tight_layout() st = fig.suptitle(fig_title, fontsize = 16) st.set_y(0.95) fig.subplots_adjust(top = 0.85) if fig_name is not None: plt.savefig(fig_name) else: plt.show() input('Press Enter to continue...') plt.close(fig)
def draw_surface3d(function_id, **kwargs): dim = 2 func = CEC2005(dim)[function_id] clusters = kwargs.get('clusters', []) angle = kwargs.get('angle', 240) rotate = kwargs.get('rotate', False) fig_name = kwargs.get('fig_name', None) boundary = Boundary(func) step = (boundary.max_bounds[0] - boundary.min_bounds[0]) / 100 X = np.arange(boundary.min_bounds[0], boundary.max_bounds[0] + step, step) Y = np.arange(boundary.min_bounds[1], boundary.max_bounds[1] + step, step) (X, Y) = np.meshgrid(X, Y) positions = (lambda .0: continue[ [ x, y] for (x, y) in .0 ])(zip(X.ravel(), Y.ravel())) solutions = (lambda .0: continue[ Individual(position) for position in .0 ])(positions) problem = Problem(func.objective_function) problem.batch_evaluate(solutions) Z = np.array((lambda .0: continue[ solution.objective_values for solution in .0 ])(solutions)) Z = Z.reshape(X.shape) fig = plt.figure(figsize = plt.figaspect(0.5)) fig.suptitle(str(func)) ax = fig.add_subplot(1, 2, 1) cset = ax.contourf(X, Y, Z, cmap = cm.coolwarm) colors = iter(cm.rainbow(np.linspace(0, 1, len(clusters)))) for cluster in clusters: color = next(colors) x = np.array((lambda .0: continue[ individual.phenome[0] for individual in .0 ])(cluster.population)) y = np.array((lambda .0: continue[ individual.phenome[1] for individual in .0 ])(cluster.population)) ax.scatter(x, y, color = color, marker = 'o', s = 10) x_border = (lambda .0: continue[ vertice[0] for vertice in .0 ])(cluster.border) x_border.append(x_border[0]) y_border = (lambda .0: continue[ vertice[1] for vertice in .0 ])(cluster.border) y_border.append(y_border[0]) ax.plot(x_border, y_border, color = color) optimal_pos = func.get_optimal_solutions()[0].phenome ax.scatter(optimal_pos[0], optimal_pos[1], color = 'w', marker = 'x', s = 100) ax = fig.add_subplot(1, 2, 2, projection = '3d') surf = ax.plot_surface(X, Y, Z, alpha = 0.8, zorder = -1, cmap = cm.coolwarm, linewidth = 0, edgecolors = 'k', antialiased = False) fig.colorbar(surf, shrink = 0.5, aspect = 5) cset = ax.contourf(X, Y, Z, zdir = 'z', zorder = -2, offset = np.amin(Z), cmap = cm.coolwarm) if rotate: for ang in range(angle, angle + 360, 10): ax.view_init(30, ang) plt.draw() plt.pause(0.001) else: ax.view_init(30, angle) plt.show() if fig_name is not None: plt.savefig(fig_name) input('Press Enter to continue...')
def __init__(self, dim, function_id): if function_id == 6: self.min_bounds = np.array([-300] * dim) self.max_bounds = np.array([600] * dim) self.init_min_bounds = np.array([0] * dim) self.init_max_bounds = np.array([600] * dim) #elif function_id == 8: # self.min_bounds = np.array([0.5, -2]) # self.max_bounds = np.array([2.5, 0]) # self.init_min_bounds = np.array([0.5, -2]) # self.init_max_bounds = np.array([2.5, 0]) elif function_id == 24: self.min_bounds = np.array([-5] * dim) self.max_bounds = np.array([10] * dim) self.init_min_bounds = np.array([2] * dim) self.init_max_bounds = np.array([5] * dim) else: self.min_bounds = np.array(CEC2005(dim)[function_id].min_bounds) self.max_bounds = np.array(CEC2005(dim)[function_id].max_bounds) self.init_min_bounds = np.array(CEC2005(dim)[function_id].min_bounds) self.init_max_bounds = np.array(CEC2005(dim)[function_id].max_bounds)
def __init__(self, max_evaluations, n_points, dimension, function_id, **kwargs): self.function_id = function_id self.n_points = n_points self.dimension = dimension self.function = CEC2005(dimension)[function_id].objective_function self.max_evaluations = max_evaluations * dimension self.max_bounds = Boundary(dimension, function_id).max_bounds self.min_bounds = Boundary(dimension, function_id).min_bounds self.optimal_position = CEC2005( dimension)[function_id].get_optimal_solutions()[0].phenome self.optimal_fitness = self.function(self.optimal_position) #self.problem = Problem(self.function.objective_function, max_evaluations=max_evaluations) self.boundary = Boundary(dimension, function_id) self.verbose = kwargs.get('verbose', False) self.population = [ ] #self.init_population( self.n_points, self.dimension ) self.algo_type = kwargs.get('algo_type', 'CMA') self.init_algo() self.iteration = 0 self.should_terminate = False self.optimal_solution = self.find_optimal_solution() self.stats = OrderedDict([ ('iteration', []), ('FEs', []), ('error', []), ('best_value', []), #('best_position',[]) ]) self.run() self.best_solution = min(self.population, key=attrgetter('objective_values'))
def draw_cluster(function_id, clusters, k, **kwargs): dim = 2 func = CEC2005(dim)[function_id] angle = kwargs.get('angle', 240) fig_name = kwargs.get('fig_name', None) cluster = clusters[k] color = cm.rainbow(np.linspace(0, 1, len(clusters)))[k] X = np.arange(0, 1.01, 0.01) Y = np.arange(0, 1.01, 0.01) (X, Y) = np.meshgrid(X, Y) positions = (lambda .0: continue[ [ x, y] for (x, y) in .0 ])(zip(X.ravel(), Y.ravel())) original_positions = cluster.transform_inverse(positions) solutions = (lambda .0: continue[ Individual(position) for position in .0 ])(original_positions) problem = Problem(func.objective_function) problem.batch_evaluate(solutions) Z = np.array((lambda .0: continue[ solution.objective_values for solution in .0 ])(solutions)) Z = Z.reshape(X.shape) fig = plt.figure(figsize = plt.figaspect(0.5)) fig.suptitle(str(func)) ax = fig.add_subplot(1, 2, 1) cset = ax.contourf(X, Y, Z, cmap = cm.coolwarm) positions = np.array((lambda .0: continue[ p.phenome for p in .0 ])(cluster.population)) transformed_positions = cluster.transform(positions) x = transformed_positions.T[0] y = transformed_positions.T[1] ax.scatter(x, y, color = color, marker = 'o', s = 10) cord = np.array([ [ 0, 0], [ 1, 0], [ 1, 1], [ 0, 1]]) ax.plot(cord[([ 0, 1, 2, 3, 0], 0)], cord[([ 0, 1, 2, 3, 0], 1)], color = color) ax = fig.add_subplot(1, 2, 2, projection = '3d') surf = ax.plot_surface(X, Y, Z, alpha = 0.8, zorder = -1, cmap = cm.coolwarm, linewidth = 0, edgecolors = 'k', antialiased = False) fig.colorbar(surf, shrink = 0.5, aspect = 5) cset = ax.contourf(X, Y, Z, zdir = 'z', zorder = -2, offset = np.amin(Z), cmap = cm.coolwarm) ax.view_init(30, angle) plt.show() if fig_name is not None: plt.savefig(fig_name) input('Press Enter to continue...')
def draw_arms(function_id, arms, **kwargs): # Parameters dim = 2 function = CEC2005(dim)[function_id].objective_function k = len(arms) inch_size = 4 fig_w = k + 1 fig_h = 1 fig = plt.figure(figsize = (fig_w * inch_size, fig_h * inch_size)) angle = kwargs.get('angle', 240) rotate = kwargs.get('rotate', False) fig_name = kwargs.get('fig_name', None) fig_title = kwargs.get('fig_title', str(func)) cmap = cm.coolwarm scatter_cmap = cm.jet(np.linspace(0.1, 0.9, k)) boundary = Boundary(dim, function_id) # Get Mesh Solutions for contour step = (boundary.max_bounds[0] - boundary.min_bounds[0]) / 100 X = np.arange(boundary.min_bounds[0], boundary.max_bounds[0] + step, step) Y = np.arange(boundary.min_bounds[1], boundary.max_bounds[1] + step, step) (X, Y) = np.meshgrid(X, Y) positions = [ [x, y] for x, y in zip(X.ravel(), Y.ravel()) ] Z = np.array( [ function(position) for position in positions ] ) # Reset colormap to get rid of extreme colors vmin = min(Z) vmax = max(Z) vmin = vmin - (vmax - vmin) * 0.2 vmax = vmax + (vmax - vmin) * 0.2 Z = Z.reshape(X.shape) # Plot contour ax = fig.add_subplot(fig_h, fig_w, 1) ax.set_xlim([ boundary.min_bounds[0], boundary.max_bounds[0]]) ax.set_ylim([ boundary.min_bounds[1], boundary.max_bounds[1]]) cset = ax.contourf(X, Y, Z, cmap = cmap, vmin = vmin, vmax = vmax) fig.colorbar(cset, aspect = 20) # Plot scatter points in each arm colors = iter(scatter_cmap) for arm in arms: color = next(colors) positions = arm.get_positions() ax.scatter(positions[:,0], positions[:,1], color = color, marker = 'o', s = 10) # Plot borders on original boundary subspace_border = np.array([ [ 0, 0], [ 1, 0], [ 1, 1], [ 0, 1], [ 0, 0]]) border = arm.matrix.inverse_transform( subspace_border ) ax.plot(border[:, 0], border[:, 1], color = color) # Plot optimal solution as a big white 'X' optimal_pos = func.get_optimal_solutions()[0].phenome ax.scatter(optimal_pos[0], optimal_pos[1], color = 'w', marker = 'x', s = 100) # Plot from each arm's perspective for (i, arm) in enumerate(arms): color = scatter_cmap[i] ax = fig.add_subplot(fig_h, fig_w, i + 2) ax.set_xlim([ -0.01, 1.01]) ax.set_ylim([ -0.01, 1.01]) # Plot contour (X, Y) = np.meshgrid( np.arange(0, 1.01, 0.01), np.arange(0, 1.01, 0.01) ) positions = [ [x, y] for x, y in zip(X.ravel(), Y.ravel())] original_positions = arm.matrix.inverse_transform(positions) Z = np.array( [ function(position) for position in original_positions ] ) Z = Z.reshape(X.shape) cset = ax.contourf(X, Y, Z, cmap = cmap, vmin = vmin, vmax = vmax) # Plot scatter points in each arm trans_X = arm.matrix.transform( arm.get_positions() ) ax.scatter(trans_X[(:, 0)], trans_X[(:, 1)], color = color, marker = 'o', s = 10) # Plot border cord = np.array([ [0, 0], [1, 0], [1, 1], [0, 1]]) ax.plot(cord[[0, 1, 2, 3, 0], 0], cord[[0, 1, 2, 3, 0], 1], color = color) fig.tight_layout() st = fig.suptitle(fig_title, fontsize = 16) st.set_y(0.95) fig.subplots_adjust(top = 0.85) if fig_name is not None: plt.savefig(fig_name) else: plt.show() input('Press Enter to continue...') plt.close(fig)
def draw_all(function_id, **kwargs): dim = 2 func = CEC2005(dim)[function_id] clusters = kwargs.get('clusters', []) angle = kwargs.get('angle', 240) rotate = kwargs.get('rotate', False) fig_name = kwargs.get('fig_name', None) cmap = cm.coolwarm scatter_cmap = cm.jet(np.linspace(0.1, 0.9, len(clusters))) boundary = Boundary(func) step = (boundary.max_bounds[0] - boundary.min_bounds[0]) / 100 X = np.arange(boundary.min_bounds[0], boundary.max_bounds[0] + step, step) Y = np.arange(boundary.min_bounds[1], boundary.max_bounds[1] + step, step) (X, Y) = np.meshgrid(X, Y) positions = (lambda .0: continue[ [ x, y] for (x, y) in .0 ])(zip(X.ravel(), Y.ravel())) solutions = (lambda .0: continue[ Individual(position) for position in .0 ])(positions) problem = Problem(func.objective_function) problem.batch_evaluate(solutions) Z = np.array((lambda .0: continue[ solution.objective_values for solution in .0 ])(solutions)) Z = Z.reshape(X.shape) fig_w = len(clusters) + 1 fig_h = 2 fig = plt.figure(figsize = plt.figaspect(float(fig_h) / fig_w)) fig.suptitle(str(func)) ax = fig.add_subplot(fig_h, fig_w, 1, projection = '3d') surf = ax.plot_surface(X, Y, Z, alpha = 0.8, zorder = -1, cmap = cmap, linewidth = 0, edgecolors = 'k', antialiased = False) fig.colorbar(surf, shrink = 0.5, aspect = 5) cset = ax.contourf(X, Y, Z, zdir = 'z', zorder = -2, offset = np.amin(Z), cmap = cmap) ax.view_init(30, angle) ax = fig.add_subplot(fig_h, fig_w, fig_w + 1) cset = ax.contourf(X, Y, Z, cmap = cmap) colors = iter(scatter_cmap) for cluster in clusters: color = next(colors) x = np.array((lambda .0: continue[ individual.phenome[0] for individual in .0 ])(cluster.population)) y = np.array((lambda .0: continue[ individual.phenome[1] for individual in .0 ])(cluster.population)) ax.scatter(x, y, color = color, marker = 'o', s = 10) x_border = (lambda .0: continue[ vertice[0] for vertice in .0 ])(cluster.border) x_border.append(x_border[0]) y_border = (lambda .0: continue[ vertice[1] for vertice in .0 ])(cluster.border) y_border.append(y_border[0]) ax.plot(x_border, y_border, color = color) optimal_pos = func.get_optimal_solutions()[0].phenome ax.scatter(optimal_pos[0], optimal_pos[1], color = 'w', marker = 'x', s = 100) for k in range(len(clusters)): cluster = clusters[k] color = scatter_cmap[k] X = np.arange(0, 1.01, 0.01) Y = np.arange(0, 1.01, 0.01) (X, Y) = np.meshgrid(X, Y) positions = (lambda .0: continue[ [ x, y] for (x, y) in .0 ])(zip(X.ravel(), Y.ravel())) original_positions = cluster.transform_inverse(positions) solutions = (lambda .0: continue[ Individual(position) for position in .0 ])(original_positions) problem = Problem(func.objective_function) problem.batch_evaluate(solutions) Z = np.array((lambda .0: continue[ solution.objective_values for solution in .0 ])(solutions)) Z = Z.reshape(X.shape) ax = fig.add_subplot(fig_h, fig_w, k + 2, projection = '3d') surf = ax.plot_surface(X, Y, Z, alpha = 0.8, zorder = -1, cmap = cmap, linewidth = 0, edgecolors = 'k', antialiased = False) fig.colorbar(surf, shrink = 0.5, aspect = 5) cset = ax.contourf(X, Y, Z, zdir = 'z', zorder = -2, offset = np.amin(Z), cmap = cmap) ax.view_init(30, angle) ax = fig.add_subplot(fig_h, fig_w, fig_w + k + 2) cset = ax.contourf(X, Y, Z, cmap = cmap) positions = np.array((lambda .0: continue[ p.phenome for p in .0 ])(cluster.population)) transformed_positions = cluster.transform(positions) x = transformed_positions.T[0] y = transformed_positions.T[1] ax.scatter(x, y, color = color, marker = 'o', s = 10) cord = np.array([ [ 0, 0], [ 1, 0], [ 1, 1], [ 0, 1]]) ax.plot(cord[([ 0, 1, 2, 3, 0], 0)], cord[([ 0, 1, 2, 3, 0], 1)], color = color) fig.tight_layout() plt.show() if fig_name is not None: plt.savefig(fig_name) input('Press Enter to continue...')
st.set_y(0.95) fig.subplots_adjust(top = 0.85) if fig_name is not None: plt.savefig(fig_name) else: plt.show() input('Press Enter to continue...') plt.close(fig) if __name__ == '__main__': nPoints = 40 dim = 2 function_id = 8 n_clusters = 3 func = CEC2005(dim)[function_id] positions = np.zeros((nPoints, dim)) boundary = Boundary(dim, function_id) for d in range(dim): positions[(:, d)] = np.random.uniform(boundary.min_bounds[d], boundary.max_bounds[d], nPoints) population = (lambda .0: continue[ Individual(position) for position in .0 ])(positions) problem = Problem(func.objective_function) problem.batch_evaluate(population) population = sorted(population, key = (lambda p: p.objective_values)) population = population[:len(population) // 2] X = np.array((lambda .0: continue[ individual.phenome for individual in .0 ])(population)) labels = KMeans(n_clusters = n_clusters).fit_predict(X) clusters = [] for k in range(n_clusters): cluster_population = []
def draw_optimization(function_id, cluster_positions, matrices, **kwargs): assert len(cluster_positions) == len(matrices) import os from optproblems.cec2005 import CEC2005 import matplotlib.pyplot as plt from matplotlib import cm from boundary import Boundary # Parameters dim = 2 function = CEC2005(dim)[function_id].objective_function optimal_pos = CEC2005(dim)[function_id].get_optimal_solutions()[0].phenome boundary = Boundary(dim, function_id) k = len(matrices) inch_size = 4 #fig_w = k + 1 fig_w = 1.2 fig_h = 1 fig = plt.figure(figsize=(fig_w * inch_size, fig_h * inch_size)) cmap = cm.coolwarm scatter_cmap = cm.jet(np.linspace(0.1, 0.9, k)) angle = kwargs.get('angle', 240) rotate = kwargs.get('rotate', False) fig_name = kwargs.get('fig_name', None) fig_title = kwargs.get('fig_title', 'F%d' % (function_id + 1)) fig_dir = kwargs.get('fig_dir', 'test_arms') if not os.path.exists(fig_dir): os.makedirs(fig_dir) print('ploting %s...' % fig_name) # Get Mesh Solutions for contour step = (boundary.max_bounds[0] - boundary.min_bounds[0]) / 100 X = np.arange(boundary.min_bounds[0], boundary.max_bounds[0] + step, step) Y = np.arange(boundary.min_bounds[1], boundary.max_bounds[1] + step, step) (X, Y) = np.meshgrid(X, Y) positions = [[x, y] for x, y in zip(X.ravel(), Y.ravel())] Z = np.array([function(position) for position in positions]) # Reset colormap to get rid of extreme colors vmin = min(Z) vmax = max(Z) vmin = vmin - (vmax - vmin) * 0.2 vmax = vmax + (vmax - vmin) * 0.2 Z = Z.reshape(X.shape) # Plot contour ax = fig.add_subplot(fig_h, fig_w, 1) #margin = (boundary.max_bounds - boundary.min_bounds)*0.1 margin = (boundary.max_bounds - boundary.min_bounds) * 0.0 ax.set_xlim([ boundary.min_bounds[0] - margin[0], boundary.max_bounds[0] + margin[0] ]) ax.set_ylim([ boundary.min_bounds[1] - margin[1], boundary.max_bounds[1] + margin[1] ]) cset = ax.contourf(X, Y, Z, cmap=cmap, vmin=vmin, vmax=vmax) fig.colorbar(cset, aspect=20) # Plot scatter points in each arm colors = iter(scatter_cmap) for positions, matrix in zip(cluster_positions, matrices): color = next(colors) ax.scatter(positions[:, 0], positions[:, 1], color=color, marker='o', s=10) # Plot borders on original boundary subspace_border = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]) border = matrix.inverse_transform(subspace_border) ax.plot(border[:, 0], border[:, 1], color=color) # Plot optimal solution as a big white 'X' ax.scatter(optimal_pos[0], optimal_pos[1], color='w', marker='x', s=100) ''' # Plot from each arm's perspective for i, (positions, matrix) in enumerate(zip(cluster_positions, matrices)): color = scatter_cmap[i] ax = fig.add_subplot(fig_h, fig_w, i + 2) ax.set_xlim([ -0.01, 1.01]) ax.set_ylim([ -0.01, 1.01]) # Plot contour (X, Y) = np.meshgrid( np.arange(0, 1.01, 0.01), np.arange(0, 1.01, 0.01) ) mesh_positions = [ [x, y] for x, y in zip(X.ravel(), Y.ravel())] original_positions = matrix.inverse_transform(mesh_positions) Z = np.array( [ function(mesh_position) for mesh_position in original_positions ] ) Z = Z.reshape(X.shape) cset = ax.contourf(X, Y, Z, cmap = cmap, vmin = vmin, vmax = vmax) # Plot scatter points in each arm trans_X = matrix.transform( positions ) ax.scatter(trans_X[:, 0], trans_X[:, 1], color = color, marker = 'o', s = 10) # Plot border cord = np.array([ [0, 0], [1, 0], [1, 1], [0, 1]]) ax.plot(cord[[0, 1, 2, 3, 0], 0], cord[[0, 1, 2, 3, 0], 1], color = color) ''' fig.tight_layout() st = fig.suptitle(fig_title, fontsize=16) st.set_y(0.95) fig.subplots_adjust(top=0.85) if fig_name is not None: plt.savefig('%s/%s' % (fig_dir, fig_name)) else: plt.show() input('Press Enter to continue...') plt.close(fig)
def draw_arms(function_id, arms, **kwargs): import os from optproblems.cec2005 import CEC2005 import matplotlib.pyplot as plt from matplotlib import cm from boundary import Boundary # Parameters dim = 2 function = CEC2005(dim)[function_id].objective_function optimal_pos = CEC2005(dim)[function_id].get_optimal_solutions()[0].phenome boundary = Boundary(dim, function_id) plot_subspace = True inch_size = 4 k = len(arms) fig_w = (k + 1.2) if plot_subspace else 1.2 fig_h = 1 fig = plt.figure(figsize=(fig_w * inch_size, fig_h * inch_size)) cmap = cm.coolwarm scatter_cmap = cm.jet(np.linspace(0.1, 0.9, k)) angle = kwargs.get('angle', 240) rotate = kwargs.get('rotate', False) fig_name = kwargs.get('fig_name', None) fig_title = kwargs.get('fig_title', 'F%d' % (function_id + 1)) fig_dir = kwargs.get('fig_dir', 'test_arms') if not os.path.exists(fig_dir): os.makedirs(fig_dir) print('ploting %s...' % fig_name) # Plot contour ax = fig.add_subplot(fig_h, fig_w, 1) #ax.set_facecolor('black') # Get Mesh Solutions for contour step = (boundary.max_bounds[0] - boundary.min_bounds[0]) / 100 X = np.arange(boundary.min_bounds[0], boundary.max_bounds[0] + step, step) Y = np.arange(boundary.min_bounds[1], boundary.max_bounds[1] + step, step) (X, Y) = np.meshgrid(X, Y) positions = [[x, y] for x, y in zip(X.ravel(), Y.ravel())] Z = np.array([function(position) for position in positions]) # Reset colormap to get rid of extreme colors v_range = max(Z) - min(Z) vmin = min(Z) - v_range * 0.2 vmax = max(Z) + v_range * 0.2 Z = Z.reshape(X.shape) #margin = (boundary.max_bounds - boundary.min_bounds)*0.1 margin = (boundary.max_bounds - boundary.min_bounds) * 0.0 ax.set_xlim([ boundary.min_bounds[0] - margin[0], boundary.max_bounds[0] + margin[0] ]) ax.set_ylim([ boundary.min_bounds[1] - margin[1], boundary.max_bounds[1] + margin[1] ]) cset = ax.contourf(X, Y, Z, cmap=cmap, vmin=vmin, vmax=vmax) fig.colorbar(cset, aspect=20) # Plot optimal solution as a big white 'X' ax.scatter(optimal_pos[0], optimal_pos[1], color='w', marker='x', s=100) # Plot scatter points in each arm colors = iter(scatter_cmap) for arm in arms: arm.draw(ax, next(colors), on_subspace=False, draw_algo=False) if plot_subspace: # Plot from each arm's perspective for i, arm in enumerate(arms): color = scatter_cmap[i] ax_sub = fig.add_subplot(fig_h, fig_w, i + 2) #ax_sub.set_facecolor('black') ax_sub.set_xlim([-0.01, 1.01]) ax_sub.set_ylim([-0.01, 1.01]) # Plot contour (X, Y) = np.meshgrid(np.arange(0, 1.01, 0.01), np.arange(0, 1.01, 0.01)) mesh_positions = [[x, y] for x, y in zip(X.ravel(), Y.ravel())] original_positions = arm.matrix.inverse_transform(mesh_positions) Z = np.array([ function(mesh_position) for mesh_position in original_positions ]) Z = Z.reshape(X.shape) #cset = ax_sub.contourf(X, Y, Z, cmap = cmap, vmin = vmin, vmax = vmax) cset = ax_sub.contour(X, Y, Z, cmap=cmap) # Plot scatter points in each arm arm.draw(ax_sub, color, on_subspace=True) fig.tight_layout() st = fig.suptitle(fig_title, fontsize=16) st.set_y(0.95) fig.subplots_adjust(top=0.85) if fig_name is not None: plt.savefig('%s/%s' % (fig_dir, fig_name)) else: plt.show() input('Press Enter to continue...') plt.close(fig)
def run(function_id, fig_dir): from boundary import Boundary dimension = 2 n_points = 200 function_id = function_id - 1 obj = CEC2005(dimension)[function_id].objective_function min_bounds = Boundary(dimension, function_id).min_bounds max_bounds = Boundary(dimension, function_id).max_bounds ''' positions = np.array([ [0.75, -1.4], [0.90, -1.4], [1.05, -1.4], [1.75, -1.4], [1.90, -1.4], [2.05, -1.4], [0.75, -1.6], [0.90, -1.6], [1.05, -1.6], [1.75, -1.6], [1.90, -1.6], [2.05, -1.6], ]) ''' positions = np.random.uniform(min_bounds, max_bounds, size=(n_points, dimension)) fitnesses = np.array([obj(p) for p in positions]) indices = fitnesses.argsort() selected = indices[:int(len(positions) / 2)] positions, fitnesses = positions[selected], fitnesses[selected] #mean, cov = weighted_gaussian( positions, fitnesses ) labels = hierarchical_clustering(positions, fitnesses) k = max(labels) + 1 clusters_positions, clusters_fitnesses = [], [] for i in range(k): indices = np.where(labels == i)[0] clusters_positions.append(positions[indices]) clusters_fitnesses.append(fitnesses[indices]) fig_name = 'F%d_init.png' % (function_id + 1) print('K = %d, drawing' % k, fig_name) draw(clusters_positions, clusters_fitnesses, obj, fig_name=fig_name, fig_dir=fig_dir, xlim=[min_bounds[0], max_bounds[0]], ylim=[min_bounds[1], max_bounds[1]]) labels = trim_by_MDL(positions, fitnesses, labels) #labels = clustering( positions, fitnesses ) k = max(labels) + 1 clusters_positions, clusters_fitnesses = [], [] for i in range(k): #print(i) indices = np.where(labels == i)[0] clusters_positions.append(positions[indices]) clusters_fitnesses.append(fitnesses[indices]) #mean, cov = weighted_gaussian( positions[indices], fitnesses[indices] ) #distances = [ manhalanobis_distance(x, mean, cov) for x in positions[indices] ] #idx = np.argsort(distances) #for i in idx: # print( positions[indices][i], fitnesses[indices][i], distances[i] ) #h = -fitnesses[indices][idx] - min(-fitnesses[indices]) #h = h/sum(h) #print(h) #n, bins, patches = plt.hist(h, len(h) #print() fig_name = 'F%d_MDL_GMM.png' % (function_id + 1) print('K = %d, drawing' % k, fig_name) draw(clusters_positions, clusters_fitnesses, obj, fig_name=fig_name, fig_dir=fig_dir, xlim=[min_bounds[0], max_bounds[0]], ylim=[min_bounds[1], max_bounds[1]])
def __init__(self, n_points=None, dimension=2, function_id=0, use_bandit=False, algo_type='CMA', max_evaluations=1e4, verbose=False, plot=0, fig_dir=None, csv_file=None): if use_bandit: algo_description = 'Bandit + %s' % algo_type else: algo_description = algo_type if csv_file: self.csv_file = open(csv_file, 'w') self.csv_file.write( 'iteration,FEs,error,best_fitness,best_position\n') if n_points is None: if algo_type == 'PSO': self.n_points = 40 elif algo_type == 'ACOR': self.n_points = 50 else: self.n_points = 30 else: self.n_points = n_points print('\n%s: Solving F%d in %dD with population size %d...\n' % (algo_description, function_id + 1, dimension, self.n_points)) # Parameters for optproblems self.dimension = dimension self.function_id = function_id self.function = CEC2005(dimension)[function_id].objective_function self.max_bounds = Boundary(dimension, function_id).max_bounds self.min_bounds = Boundary(dimension, function_id).min_bounds self.init_max_bounds = Boundary(dimension, function_id).init_max_bounds self.init_min_bounds = Boundary(dimension, function_id).init_min_bounds # Parameters for termination self.FE = 0 self.iteration = 0 self.max_evaluations = max_evaluations * dimension self.termination_error = 1e-8 self.should_terminate = False # Parameters for logging self.optimal_position = CEC2005( dimension)[function_id].get_optimal_solutions()[0].phenome self.optimal_fitness = self.function(self.optimal_position) self.best_position = np.zeros_like(self.optimal_position) self.best_fitness = np.inf self.verbose = verbose self.plot = plot self.stats = OrderedDict([('iteration', []), ('FEs', []), ('error', []), ('best_fitness', []), ('best_position', [])]) if use_bandit == True: self.algo = Bandit( self.obj, self.n_points, self.dimension, algo_type=algo_type, min_bounds=self.min_bounds, max_bounds=self.max_bounds, init_max_bounds=self.init_max_bounds, init_min_bounds=self.init_min_bounds, verbose=verbose, max_evaluations=self.max_evaluations, max_arms_num=10, ) elif algo_type == 'PSO': self.algo = PSO(self.obj, self.n_points, self.dimension, min_bounds=self.min_bounds, max_bounds=self.max_bounds) elif algo_type == 'ACOR': self.algo = ACOR( self.obj, self.dimension, min_bounds=self.min_bounds, max_bounds=self.max_bounds, ants_num=2, archive_size=self.n_points, # 50 q=1e-4, #1e-4, 0.1, 0.3, 0.5, 0.9 xi=0.85) else: self.algo = CMA(self.obj, self.n_points, self.dimension, min_bounds=self.min_bounds, max_bounds=self.max_bounds)
def testArm(plot=False): from optproblems.cec2005 import CEC2005 from sklearn.cluster import KMeans from boundary import Boundary function_id = 6 # 0 ~ 24 algo_type = 'ACOR' dimension = 2 n_points = 50 init_num_points = 100 * dimension n_sample = 100 * dimension k = 1 function = CEC2005(dimension)[function_id].objective_function init_min_bounds = Boundary(dimension, function_id).init_min_bounds init_max_bounds = Boundary(dimension, function_id).init_max_bounds min_bounds = Boundary(dimension, function_id).min_bounds max_bounds = Boundary(dimension, function_id).max_bounds init_positions = np.random.uniform(init_min_bounds[0], init_max_bounds[0], size=(init_num_points, dimension)) init_fitnesses = np.array([function(p) for p in init_positions]) index = init_fitnesses.argsort() selected = index[:int(init_num_points / 2)] positions, fitnesses = init_positions[selected], init_fitnesses[selected] labels = KMeans(n_clusters=k).fit_predict(positions) it = 0 should_terminate = False arms = [] for i in range(k): indices = np.where(labels == i)[0] arm = Arm(function, n_points, positions[indices], fitnesses[indices], algo_type=algo_type, exclude=[], matrix=Matrix(positions[indices], fitnesses[indices], min_bounds, max_bounds), min_bounds=min_bounds, max_bounds=max_bounds) arms.append(arm) if plot: draw_arms(function_id, arms, fig_name='initialize.png') trans_samples = np.random.uniform(0, 1, size=(n_sample, dimension)) for i in range(k): indices = np.where(labels == i)[0] argmax = np.argmax(fitnesses[indices]) best = positions[indices][argmax] opt_points = [] exclude = [] for j in range(k): if i != j: samples = arms[j].matrix.inverse_transform(trans_samples) exclude.extend(samples) opt_points.append(samples) else: opt_points.append(positions[indices]) exclude = np.array(exclude) print('optimizing matrix of arm %d ...' % i) arms[i].matrix.optimize(positions[indices], fitnesses[indices], exclude) if plot: draw_optimization(function_id, opt_points, [arm.matrix for arm in arms], fig_name='optimize_%d.png' % i) if plot: draw_arms(function_id, arms, fig_name='optimized.png') new_matrix = deepcopy(arms[0].matrix) translate = np.array([[1, 0, -0.5], [0, 1, 0.5], [0, 0, 1]]) new_matrix.matrix = np.dot(new_matrix.matrix, translate) arms[0].transform(new_matrix) if plot: draw_arms(function_id, arms, fig_name='transformed.png') '''
plt.savefig('%s/%s' % (fig_dir, fig_name)) plt.close(fig) def manhalanobis_distance( x, mean, cov ): assert len(x) == len(mean) == len(cov) == len(cov[0]) xm = x - mean inverse_cov = np.linalg.inv(cov) return xm.dot(inverse_cov).dot(xm.T) function_id = 8 dimension = 2 obj = CEC2005(dimension)[function_id].objective_function xlim = [1.5 ,3.25] ylim = [-2, -1] positions = np.random.uniform([xlim[0], ylim[0]], [xlim[1], ylim[1]], size=(20,2)) fitnesses = np.array([ obj(x) for x in positions ]) draw( obj, 'test.png', xlim=xlim, ylim=ylim, scatter = positions ) from cluster import weighted_gaussian mean, cov = weighted_gaussian( positions, fitnesses ) from scipy.stats import multivariate_normal rv = multivariate_normal(mean, cov) from cluster import clustering labels = clustering(positions, fitnesses) print('mean:', mean) print('cov:\n', cov) print(labels)
def __init__(self, n_points=12, dimension=2, function_id=1, algo_type='CMA', max_evaluations=10000, verbose=False, plot=0, fig_dir=None): print( '\nBandit + %s: Solving F%d in %dD with population size %d...\n' % (algo_type, function_id, dimension, n_points)) from optproblems.cec2005 import CEC2005 from boundary import Boundary # Bandit parameters self.n_points = n_points self.dimension = dimension self.function_id = function_id - 1 self.function = CEC2005(dimension)[self.function_id].objective_function max_bounds = Boundary(dimension, self.function_id).max_bounds min_bounds = Boundary(dimension, self.function_id).min_bounds init_max_bounds = Boundary(dimension, self.function_id).init_max_bounds init_min_bounds = Boundary(dimension, self.function_id).init_min_bounds # Termination parameters self.FE = 0 self.iteration = 0 self.max_evaluations = max_evaluations * dimension self.termination_error = 1e-08 self.should_terminate = False self.optimal_position = CEC2005(dimension)[ self.function_id].get_optimal_solutions()[0].phenome self.optimal_fitness = self.function(self.optimal_position) self.best_position = np.zeros_like(self.optimal_position) self.best_fitness = np.inf self.verbose = verbose self.plot = plot self.fig_config = { 'fig_dir': fig_dir, 'angle': 240, 'xlim': [min_bounds[0], max_bounds[0]], 'ylim': [min_bounds[1], max_bounds[1]], 'optimal': self.optimal_position } self.algo = Bandit(self.obj, self.n_points, self.dimension, algo_type=algo_type, min_bounds=min_bounds, max_bounds=max_bounds, init_max_bounds=init_max_bounds, init_min_bounds=init_min_bounds, verbose=verbose, max_evaluations=self.max_evaluations, max_arms_num=10, plot=plot, fig_config=self.fig_config) if self.plot > 0: error = self.best_fitness - self.optimal_fitness self.fig_config['fig_title'] = ( 'F%d, FE=%d, error=%.2e' % (self.function_id + 1, self.FE, error)) draw_arms(self.function_id, self.algo.arms, fig_name='it%d.png' % self.iteration, **self.fig_config)