def optimize(self, nPts=3, ns=100, nPop=40, epochs=500, K=0, phi=2.05,
vel_fact=0.5, conf_type='RB', IntVar=None, normalize=False,
rad=0.1, f_interp='cubic', Xinit=None):
"""
Optimizes the path.
"""
# Arguments passed to the function to minimize (<args> has five items)
Xs = np.ones((nPop, 1)) * self.start[0] # Start x-position (as array)
Ys = np.ones((nPop, 1)) * self.start[1] # Start y-position (as array)
Xg = np.ones((nPop, 1)) * self.goal[0] # Goal x-position (as array)
Yg = np.ones((nPop, 1)) * self.goal[1] # Goal y-position (as array)
args = [(Xs, Ys), (Xg, Yg), self.obs, ns, f_interp]
# Boundaries of the search space
nVar = 2 * nPts
UB = np.zeros(nVar)
LB = np.zeros(nVar)
LB[:nPts] = self.limits[0]
UB[:nPts] = self.limits[1]
LB[nPts:] = self.limits[2]
UB[nPts:] = self.limits[3]
# Optimize
X, info = PSO(path_lenght, LB, UB, nPop, epochs, K, phi, vel_fact,
conf_type, IntVar, normalize, rad, args, Xinit)
# Get the results for the best path (<args> has six items)
args = [self.start, self.goal, self.obs, ns, f_interp, []]
F = path_lenght(X.reshape(1, nVar), args)
L, count, Px, Py = args[5]
self.sol = (X, L[0], count, Px, Py)
def start_tranning(self):
@pyqtSlot()
def train_settting():
for obj in self.run_group:
obj.setDisabled(True)
self.train_btn.setDisabled(True)
self.stop_train_btn.setEnabled(True)
self.train_progress.setMaximum(self.iter_times.value())
current_data = self.trainning_data_selector.currentText()
train_data = self.train_dataset[current_data]
m_range = (min(min(data["data"]) for data in train_data),
max(max(data["data"]) for data in train_data))
self.rbfn = RBFN(self.num_neuron.value(), len(train_data[0]["data"]))
self.trainning_thread = PSO(train_data, self.iter_times.value(),
self.population_size.value(), m_range,
self.inertia_weight.value(),
self.social_weight.value(),
self.cognitive_weight.value(), self.rbfn)
self.trainning_thread.sig_train_detail.connect(self.show_train_detail)
self.stop_train_btn.clicked.connect(self.trainning_thread.stop)
self.trainning_thread.started.connect(train_settting)
self.trainning_thread.finished.connect(self.__reset_controller)
self.running_threads.append(self.trainning_thread)
self.thread_running = True
self.trainning_thread.start()
def __init__(self,
num_samples,
population_size,
topology,
train_data,
test_data,
directory,
problem_type='classification',
max_limit=2,
min_limit=-2):
self.num_samples = num_samples
self.pop_size = population_size
self.topology = topology
self.train_data = train_data
self.test_data = test_data
self.problem_type = problem_type
self.directory = directory
self.w_size = (topology[0] * topology[1]) + (
topology[1] * topology[2]) + topology[1] + topology[2]
self.neural_network = Network(topology, train_data, test_data)
self.min_limits = np.repeat(min_limit, self.w_size)
self.max_limits = np.repeat(max_limit, self.w_size)
self.initialize_sampling_parameters()
self.create_directory(directory)
PSO.__init__(self, self.pop_size, self.w_size, self.max_limits,
self.min_limits, self.neural_network.evaluate_fitness)
def run_PSO_WD(data_managers,
deltas,
C=1.0,
method='LR_labeled',
soft_pathscore=True,
path_weights=None,
nos=None):
logger = logging.getLogger(__name__)
model_name = 'WD(PSO)_' + ("soft_" if soft_pathscore else "hard_") + method
logger.info(logconfig.key_log(logconfig.MODEL_NAME, model_name))
if 'labeled' in method:
sims = data_managers[0].deltas
labels = data_managers[0].labels
elif 'dataless' in method:
if settings.soft_sim:
sims = list(
map(lambda sim: normalize(sim, axis=1), data_managers[0].sims))
else:
sims = list(
map(lambda sim: hardmax(sim, axis=1), data_managers[0].sims))
labels = list(
map(lambda sim: np.argmax(sim, axis=-1), data_managers[0].sims))
else:
raise NotImplementedError
start = time.time()
model_list = train_WD(data_managers[0].xit, sims, C, method)
def score_function(path_weights):
labeled_pres = predict_label_WD_pathscore(
model_list,
data_managers[0].xit,
deltas=(None if soft_pathscore else deltas),
path_weights=path_weights)
return compute_overall_p_r_f1(labels, labeled_pres,
nos)[2][settings.main_metric]
pso = PSO(path_weights,
score_function,
group_size=settings.pso_group_size,
min_x=settings.pso_min_x,
max_x=settings.pso_max_x)
pso.update(c1=settings.pso_c1,
c2=settings.pso_c2,
w=settings.pso_w,
max_iter=settings.pso_max_iter,
patience=settings.pso_patience)
path_weights = pso.get_best_x()
logger.info("training time: " + str(time.time() - start))
logger.info('best_path_weight: %s' % (str(path_weights)))
start = time.time()
test_pres = predict_label_WD_pathscore(
model_list,
data_managers[2].xit,
deltas=(None if soft_pathscore else deltas),
path_weights=path_weights)
logger.info("predicting time: " + str(time.time() - start))
return model_list, test_pres
class PSOVisualization:
def configure_axes(self):
self.ax.set_xlabel('x[0]')
self.ax.set_ylabel('x[1]')
self.ax.set_zlabel('Particle\'s fitness')
self.ax.set_xlim3d(self.pso.a, self.pso.b)
self.ax.set_ylim3d(self.pso.a, self.pso.b)
self.ax.set_zlim3d(min(self.z_values) - 1, max(self.z_values) + 1)
def update_3d_visualization(self, generation_no):
# collect information for 3d visualization
for i in range(self.pso.pop_size):
self.x_coords[i] = self.pso.population[i].position[0]
self.y_coords[i] = self.pso.population[i].position[1]
self.z_values[i] = self.pso.population[i].evaluation
self.configure_axes()
self.graph.set_data(self.x_coords, self.y_coords)
self.graph.set_3d_properties(self.z_values)
self.title.set_text('function = ' + self.fitness.__name__ +
'\nbest_found = ' + str(self.pso.swarm.global_minimum_found) +
'\ngeneration_no = ' + str(generation_no))
self.pso.run_one_iteration_pso_algorithm()
return self.title, self.graph,
def __init__(self, fitness, constants):
self.pso = PSO(fitness, constants)
self.fitness = fitness
self.fig = plt.figure(figsize=(15, 15))
self.ax = self.fig.add_subplot(111, projection='3d')
self.title = self.ax.set_title('')
# initialization of the particles coords for the 3d visualisation
self.x_coords = [0 for _ in range(self.pso.pop_size)]
self.y_coords = [0 for _ in range(self.pso.pop_size)]
self.z_values = [0 for _ in range(self.pso.pop_size)]
self.graph, = self.ax.plot(xs=self.x_coords, ys=self.y_coords, zs=self.z_values,
linestyle="", marker=".")
def start_pso_visualizer(self):
self.pso.pop_initialisation()
# Set up formatting for the movie files
Writer = animation.writers['ffmpeg']
writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)
ani = animation.FuncAnimation(self.fig, self.update_3d_visualization, self.pso.generations_no,
interval=1, blit=False, repeat=True, repeat_delay=5000)
ani.save('./images/pso_visualization.mp4', writer=writer)
plt.show()
def __init__(self,
num_samples,
burn_in,
population_size,
topology,
train_data,
test_data,
directory,
temperature,
swap_sample,
parameter_queue,
problem_type,
main_process,
event,
active_chains,
num_accepted,
swap_interval,
max_limit=(10),
min_limit=-10):
# Multiprocessing attributes
multiprocessing.Process.__init__(self)
self.process_id = temperature
self.parameter_queue = parameter_queue
self.signal_main = main_process
self.event = event
self.active_chains = active_chains
self.num_accepted = num_accepted
self.event.clear()
self.signal_main.clear()
# Parallel Tempering attributes
self.temperature = temperature
self.swap_sample = swap_sample
self.swap_interval = swap_interval
self.burn_in = burn_in
# MCMC attributes
self.num_samples = num_samples
self.topology = topology
self.train_data = train_data
self.test_data = test_data
self.problem_type = problem_type
self.directory = directory
self.w_size = (topology[0] * topology[1]) + (
topology[1] * topology[2]) + topology[1] + topology[2]
self.neural_network = Network(topology, train_data, test_data)
self.min_limits = np.repeat(min_limit, self.w_size)
self.max_limits = np.repeat(max_limit, self.w_size)
self.initialize_sampling_parameters()
self.create_directory(directory)
PSO.__init__(self,
pop_size=population_size,
num_params=self.w_size,
max_limits=self.max_limits,
min_limits=self.min_limits,
fitness_function=self.neural_network.evaluate_fitness,
problem_type=self.problem_type)
def train_PSO(function, comparator, n_iter, n_particle, n_neighbor, min_bound,
max_bound,
cognitive_trust, social_trust, inertia_start, inertia_end,
velocity_max):
pso = PSO(function.dimension, function.evaluate, max_iter=n_iter,
n_particle=n_particle, n_neighbor=n_neighbor,
comparator=comparator,
min_bound=min_bound, max_bound=max_bound,
cognitive_trust=cognitive_trust, social_trust=social_trust,
inertia_start=inertia_start, inertia_end=inertia_end,
velocity_max=velocity_max, version=2011, endl='\r')
pso.run()
return pso
def main():
iterations = 100
simulation_runs = 5
num_particles = 36
num_archived = 10
num_dimensions = 5
inertia_weight = 1.5
constriction_factor = 0.5
pso = PSO(max_iter=iterations,
simulation_runs=simulation_runs,
num_particles=num_particles,
num_output_features=num_archived,
num_dimensions=num_dimensions,
inertia_weight=inertia_weight,
constriction_factor=constriction_factor)
topology_list = ['full-graph', 'ring', '4-neighbours']
pso_variant_list = ['main', 'inertia-weight', 'constriction-factor']
influence_model_list = [(1.03, 2.07), (2.10, 2.20), (1.0, 2.0)]
objective_function_list = [(rastrigin, 0, [(-5.12, 5.12), (-5.12, 5.12),
(-5.12, 5.12), (-5.12, 5.12),
(-5.12, 5.12)], [(0, 0), (0, 0),
(0, 0), (0, 0),
(0, 0)]),
(griewank, 0, [(-100, 100), (-100, 100),
(-100, 100), (-100, 100),
(-100, 100)], [(0, 0), (0, 0),
(0, 0), (0, 0),
(0, 0)])]
table_data = []
for objective_function in objective_function_list:
for topology in topology_list:
for pso_variant in pso_variant_list:
for influence_model in influence_model_list:
solution, objective_function_value, error_value = pso.run(
topology, pso_variant, influence_model,
objective_function)
table_data += [[
objective_function[0].__name__, pso_variant, topology,
str(influence_model),
str(solution), objective_function_value, error_value
]]
print_table_data(table_data)
def test002():
dims = (400, 300)
mins = [0, 0, 0, 3, 3, 3]
maxes = [20, 8, 12, 12, 12, 12]
root = Tk()
root.geometry(str(dims[0]) + 'x' + str(dims[1]))
# domain specific
numBoxes = 1
correct = [5., 0., 10., 3,7,7]
problem = PrismProblem(
root, dims, numBoxes,
mins*numBoxes, maxes*numBoxes,
radius=20
)
correct_img = problem.get_image(correct)
correct_img.save('../data/correct.bmp')
swarm = PSO(
zip(mins*numBoxes, maxes*numBoxes),
problem.get_likelihood_func
)
first_guess = swarm.optimize(
10, 50, correct_img,
lambda x: render_particles(root, dims, x)
)
print 'First guess: ', first_guess
print 'First score: ', np.linalg.norm(np.subtract(first_guess, correct))
metropolis = MH(
problem.get_next,
problem.get_likelihood_func,
problem.get_prior_prob,
lambda x: problem.render(problem.get_image(x), x)
)
# execution
first_guess = problem.get_random_cube()
guess = metropolis.optimize(
correct_img, first_guess, trials=160
)
im = problem.get_image(guess)
im.save('../data/guess.bmp')
print guess
print 'Score: ', np.linalg.norm(np.subtract(guess, correct))
def main():
# 获取 parser
parser = get_parser()
params = parser.parse_args()
print(params)
# 加载数据
assert (params.case_id >= 0), '未指定案例ID --case_id'
path = 'data/case_%d.txt' % params.case_id
n, m, sche, times = load_data(path)
# 模型加载，训练
model = PSO(params, n, m, sche, times)
model.train()
def shortest_round_trip():
""" Returns a list of indices that should be visited to start at the point
at index 0 and end at the same point while visiting each other point at
least once.
"""
# replace this implementation
particles_list = []
shortest_path = []
for i in range(0, 20):
shuffle(points) #partitioning the points list
p = particle(points) #instatiating the Particle object
particles_list.append(p) #adding the points in the particle list
min = 1000 #initializing the current mininmum disstance
bit = 0 #bit (integer) to be used as a variable to find the optimal solution(path)
#if statement to fidn the new best solution(path)
for i in range(0, 10):
pso = PSO(particles_list) # instatiating the PSO object
gbest = pso.startPso() # statring the PSO algorithm
if min >= gbest.get_distance(gbest.get_Position()):
min = gbest.get_distance(
gbest.get_Position()
) #assigning the new and best solution or path to the min variable
shortest_path = gbest.get_Position(
) #assising the new and best solution or path to the shortest_position variable
print(str(min))
print(shortest_path)
optimal_particle = [] #list to store the indices of the shortest path
for r in range(0, len(shortest_path)):
p = shortest_path[
r] #assising the current point in the shortest path to p
for i in range(0, len(points)):
#if statement to store the index in the optimal_particle list
if p == points[i]:
optimal_particle.append(i)
optimal_particle.append(
optimal_particle[0]
) #adding the first point as the last point in the list
return optimal_particle
def __init__(self, fitness, constants):
self.pso = PSO(fitness, constants)
self.fitness = fitness
self.fig = plt.figure(figsize=(15, 15))
self.ax = self.fig.add_subplot(111, projection='3d')
self.title = self.ax.set_title('')
# initialization of the particles coords for the 3d visualisation
self.x_coords = [0 for _ in range(self.pso.pop_size)]
self.y_coords = [0 for _ in range(self.pso.pop_size)]
self.z_values = [0 for _ in range(self.pso.pop_size)]
self.graph, = self.ax.plot(xs=self.x_coords, ys=self.y_coords, zs=self.z_values,
linestyle="", marker=".")
def set_PSO(self,):
self.pso = PSO()
self.pso.set_cost_function(self.cost_function)
self.pso.update_w = True
self.pso.set_start_position(self.start_parameters)
self.pso.set_bounds(1.0)
self.pso.set_speed(-0.25,0.25)
def run_experiment(function_name,
topology,
param_pair,
pso_variant,
num_particles=NUM_POPULATION,
num_inter=NUM_ITERATIONS):
print("------------START EXPERIMENT-------------")
print_experiment_settings(function_name, pso_variant, topology, param_pair)
function = getattr(cost_functions, f"{function_name}_fn")
err_best_all = sys.maxsize
pos_best_all = None
for i in range(10):
err_best, pos_best = PSO.run(function, (-5.12, 5.12), pso_variant,
num_particles, num_inter, topology,
param_pair)
if err_best < err_best_all:
err_best_all = err_best
pos_best_all = pos_best
err_best_all = format(err_best_all, '.10f')
pos_best_all = [format(x, '.10f') for x in pos_best_all]
print(f'Best Position: {pos_best_all}')
print(f'Best error: {err_best_all}')
print("-------------END EXPERIMENT--------------\n\n")
return err_best_all, pos_best_all
def __init__(self):
self._population = Population(2,2)
self._ea = EA(2)
self._hc = HillClimbing(2)
self._particles=ParticlePopulation(2,2)
self._pso=PSO(self._particles)
self._controller = Controller(self._population,self._ea,0,0,self._hc, self._particles.populationGenerate,self._pso)
def findPath(startPoint, end, avoid_ball=False):
global FLAG_PATH_RECEIVED, REPLAN
FLAG_PATH_RECEIVED = 1
REPLAN = 1
global v, expectedTraverseTime, kubid
global start, target
global pso, errorInfo
startPt = point_2d()
target = point_2d()
startPt.x = startPoint.x
startPt.y = startPoint.y
target.x = end.x
target.y = end.y
# print("Start Point ",startPt.x,startPt.y)
# print("Target Point",target.x,target.y)
# print("Waiting for service")
rospy.wait_for_service('planner')
planner = rospy.ServiceProxy('planner', path_plan)
message = planner(startPt, target, avoid_ball)
path = []
for i in xrange(len(message.path)):
path = path + [
Vector2D(int(message.path[i].x), int(message.path[i].y))
]
start = rospy.Time.now()
start = 1.0 * start.secs + 1.0 * start.nsecs / pow(10, 9)
v = Velocity(path, start, startPt)
v.updateAngle()
expectedTraverseTime = v.getTime(v.GetPathLength())
global time_cal
time_cal = expectedTraverseTime
pso = PSO(5, 20, 1000, 1, 1, 0.5)
errorInfo = Error()
def test(func_name, dimension_count, iteration_count, sample_count, cpu_count):
''' this function will run all metaheurstic algorithms against
the given function for the specified amount of samples.
the mean value will be output in a file for each algorithm
for each iteration, showcasing the convergence over time
'''
fun = Function(func_name)(dimension_count)
xstar = fun.eval(fun.xstar)
f_n = Population(iteration_count, 40, 0.1, 1.0, 1.0)
f_b = Population(iteration_count, 40, 0.5, 1.0, 1.0)
f_c = Population(iteration_count, 40, 1.0, 1.0, 1.0)
pso = PSO(iteration_count, 40, 2.0, 2.0)
sma = SA(1000, 0.01)
samples = [[], [], [], [], []]
calc_mean = lambda a: np.mean(np.array(a), axis=0)
with open('./data/' + func_name + '.dat', 'w') as out_file:
try:
out_file.write('iters xstar fa faboltz facauchy pso sa\n')
for _ in range(sample_count):
samples[0].append(
f_n.iter_test(func_name, dimension_count, Population.NONE,
cpu_count))
samples[1].append(
f_b.iter_test(func_name, dimension_count,
Population.BOLTZMANN, cpu_count))
samples[2].append(
f_c.iter_test(func_name, dimension_count,
Population.CAUCHY, cpu_count))
samples[3].append(pso.iter_test(func_name, dimension_count))
samples[4].append(
sma.iter_test(func_name, dimension_count, iteration_count,
SA.CAUCHY))
# we add 1 to count for the initial case
final = np.array([np.arange(iteration_count + 1)] +
[np.array([xstar] * (iteration_count + 1))] +
[calc_mean(data) for data in samples])
for line in final.T:
line.toout_file(file, sep='\t')
out_file.write('\n')
except Exception as exc:
out_file.write(str(exc))
def test003():
dims = (400, 300)
mins = [0, 0, 0, 0, 0]
maxes = [3, 7, 7, 7, 7]
root = Tk()
root.geometry(str(dims[0]) + 'x' + str(dims[1]))
# domain specific
numBoxes = 2
correct = [1., 2., 3., 6., 2.] + [3., 2., 3., 6., 2.]
problem = FurnitureProblem(
root, dims, numBoxes,
mins*numBoxes, maxes*numBoxes,
radius=12
)
correct_img = problem.get_image(correct)
correct_img.save('../data/correct.bmp')
swarm = PSO(
zip(mins*numBoxes, maxes*numBoxes),
problem.get_likelihood_func
)
first_guess = swarm.optimize(
8, 3, correct_img,
lambda x: render_particles(root, dims, x)
)
print 'First guess: ', first_guess
print 'First score: ', np.linalg.norm(
np.subtract(first_guess, correct)
)
metropolis = MH(
problem.get_next,
problem.get_likelihood_func,
problem.get_prior_prob,
lambda x: problem.render(problem.get_image(x), x)
)
guess = metropolis.optimize(
correct_img, first_guess, trials=900
)
im = problem.get_image(guess)
im.save('../data/guess.bmp')
print 'Guess: ', guess
print 'Score: ', np.linalg.norm(np.subtract(guess, correct))
def test001():
dims = (400, 300)
mins = [0, 0, 0, 2]
maxes = [17, 15, 15, 8]
root = Tk()
root.geometry(str(dims[0]) + 'x' + str(dims[1]))
# domain specific
numBoxes = 1
correct = [0., 0., 0., 5.]
problem = CubeProblem(
root, dims, numBoxes,
mins*numBoxes, maxes*numBoxes,
radius=20
)
correct_img = problem.get_image(correct)
correct_img = Image.open('../data/test-real.bmp')
correct_img.save('../data/correct.bmp')
swarm = PSO(
zip(mins*numBoxes, maxes*numBoxes),
problem.get_likelihood_func
)
first_guess = swarm.optimize(
8, 60, correct_img,
lambda x: render_particles(root, dims, x)
)
print 'First guess: ', first_guess
print 'First score: ', np.linalg.norm(np.subtract(first_guess, correct))
metropolis = MH(
problem.get_next,
problem.get_likelihood_func,
problem.get_prior_prob,
lambda x: problem.render(problem.get_image(x), x)
)
guess = metropolis.optimize(
correct_img, first_guess, trials=200
)
im = problem.get_image(guess)
im.save('../data/guess.bmp')
print 'Guess: ', guess
print 'Score: ', np.linalg.norm(np.subtract(guess, correct))
def runTest():
global iter_max
global num_group
if ui_obj.lineEdit.text() and ui_obj.lineEdit_2.text():
iter_max = int(ui_obj.lineEdit.text())
num_group = int(ui_obj.lineEdit_2.text())
else:
iter_max = 100
num_group = 150
# 绘制图一
drawCitiesPoint()
# 运行主程序进行仿真测试
pso = PSO(num_city = data.shape[0],data = data.copy(),num_group = num_group,iter_max = iter_max,ui_obj = ui_obj)
Best_path, Best_length = pso.run()
Best_path = list(map(lambda x: x+1,Best_path))
frontText = ui_obj.textEdit.toPlainText()
backText = '迭代结束后的最短距离是：' + str(Best_length) + '\n' + '迭代结束后的最佳路径是：' + '\n' + str(Best_path)
ui_obj.textEdit.setText(frontText + backText)
plt.show()
def _task2(F, T, N):
a = np.zeros((10, ))
for i in range(10):
t = time.time()
pso = PSO(num_var=10,
population_size=N,
max_generation=10**9 + 7,
function=F,
topology=T,
seed=19520624 + i)
fitness = pso.optimize()[1]
pso.print_log()
del pso
gc.collect()
a[i] = fitness
print('\t', i, F, T, N, 'time: ', time.time() - t)
return (F, T, N), np.mean(a), np.std(a)
def train_PSO_PSO(function):
dim = 5
opso = PSO(dim,
lambda param: train_mean_PSO(function, minimise, 20, 2000, -5,
10, *active_PSO(*param)),
40,
30,
inertia_start=0.5,
inertia_end=0.5,
comparator=minimise,
min_bound=MIN_BOUND,
max_bound=MAX_BOUND,
endl='\n\n')
print('oui')
opso.run()
params = active_PSO(*opso.best_position)
print(params)
pso = train_PSO(function, minimise, 20, 500, -5, 10, *params)
print("---", pso.best_score, "---", pso.best_position)
graph_opso(pso, opso)
def particles_prevelance():
P = generate_p(2)
x, f_x = PSO(RASTRIGIN, OPSEG_RASTRIGIN, 20, 30, 0, P, 2, True)
print(x, f_x)
p = Populacija(RASTRIGIN, OPSEG_RASTRIGIN, 2, 1.7, 30, 0.75, 0.15, 20, 1,
20, True)
x, f_x = p.GenerisiGeneracije()
print(x, f_x)
x_best, f_best = ACO(RASTRIGIN, OPSEG_RASTRIGIN, 20, 30, 50, 0.0001, 0.5,
2, True)
print(x_best, f_best)
def main():
parser = argparse.ArgumentParser(description='Building and optimization of \
TSK0 model for sovling irises classification problem')
parser.add_argument('-nc', '--nClusters', help='Number of clusters in Kohonen network', \
type=int, default=10)
parser.add_argument('-np', '--nParticles', help='Number of particles in PSO', \
type=int, default=20)
parser.add_argument('-s', '--seed', help='Seed for RNG', \
type=int, default=1)
parser.add_argument('-ts', '--testSize', type=float, default=0.2, \
help = 'Relative size of test data set')
parser.add_argument('-dp', '--dataPath', type=str, default='../data/iris.data', \
help = 'Path to file with the iris dataset')
parser.add_argument('-vm', '--validationMethod', type=str, default='oneshot', \
help = 'Validation method', choices=[str('oneshot'), str('crossv')])
parser.add_argument('-k', '--foldsNumber', type=int, default=4, \
help = 'Number of folds in cross-validation')
args = parser.parse_args()
nameToDigit = {'Iris-virginica': 1, 'Iris-setosa': 2, 'Iris-versicolor': 3}
dataSet = loadNormalizedData(args.dataPath, 4, nameToDigit)
printIf('Dataset loaded')
if (args.validationMethod == str('oneshot')):
random.seed(args.seed)
xTrain, yTrain, xTest, yTest = splitDataset(dataSet[0], dataSet[1], \
args.testSize, args.seed)
clusterCenters = getKohonenClusters(xTrain, args.nClusters, args.seed)
printIf('Clusters found: {}'.format(len(clusterCenters)))
printIf('Building model...')
model = TSK0()
model.initFromClusters(clusterCenters, xTrain, yTrain)
printIf('Testing model...')
printIf('Train score: {}'.format(model.score(xTrain, yTrain)))
printIf('Test score: {}'.format(model.score(xTest, yTest)))
printIf('Optimizing model...')
initialParams = model.code()
newParams = PSO(lambda x: getTSK0Score(model, x, xTrain, yTrain),
model.code(), model.getParametersBounds(), args.nParticles, args.seed)
model.decode(newParams)
printIf('Testing model...')
printIf('Train score: {}'.format(model.score(xTrain, yTrain)))
printIf('Test score: {}'.format(model.score(xTest, yTest)))
elif(args.validationMethod == str('crossv')):
printIf('Start cross-validation...')
score, stdDev = getTSK0KFoldCVScore( \
lambda xTrain, yTrain, xTest, yTest, conn: buildAndTestModel( \
args, xTrain, yTrain, xTest, yTest, conn), dataSet[0], dataSet[1],\
args.foldsNumber, args.seed)
printIf('Cross-validation score: {}, standard deviation: {}'.format(score, stdDev))
def perform_iterations(particles, clusters, iterations, inertia, cognitive,
social):
"""
Performs five runs of the PSO clustering algorithm.
:param particles: number of particles.
:param clusters: number of clusters.
:param iterations: number of iterations.
:param inertia: inertia parameter.
:param cognitive: cognitive factor.
:param social: social factor.
:return: creates an output file with results from the best run in terms of fitness.
"""
best_fitness_idx = 0
all_fitness = []
all_outputs = []
for i in range(5):
print("\n\nSTARTING GLOBAL ITERATION {0}\n\n".format(i + 1))
pso = PSO(tfidf, file_manager)
output_str, fitness = pso.clustering(num_particles=particles,
num_clusters=clusters,
iterations=iterations,
inertia=inertia,
cognitive=cognitive,
social=social)
all_fitness.append(fitness)
all_outputs.append(output_str)
if fitness < all_fitness[best_fitness_idx]:
best_fitness_idx = i
with open(
"outputs/bbc-{0}-{1}-{2}-{3}-{4}-{5}-{6}".format(
iterations, particles, clusters, inertia, cognitive, social,
all_fitness[best_fitness_idx]), 'w') as f:
f.write(all_outputs[best_fitness_idx])
def test(func_name, dimension_count, iteration_count, sample_count, cpu_count):
''' this function will run all metaheurstic algorithms against
the given function for the specified amount of samples.
the mean value will be output in a file for each algorithm
for each iteration, showcasing the convergence over time
'''
fun = Function(func_name)(dimension_count)
xstar = fun.eval(fun.xstar)
f_n = Population(iteration_count, 40, 0.1, 1.0, 1.0)
f_b = Population(iteration_count, 40, 0.5, 1.0, 1.0)
f_c = Population(iteration_count, 40, 1.0, 1.0, 1.0)
pso = PSO(iteration_count, 40, 2.0, 2.0)
sma = SA(1000, 0.01)
samples = [[], [], [], [], []]
calc_mean = lambda a: np.mean(np.array(a), axis=0)
with open('./data/' + func_name + '.dat', 'w') as out_file:
try:
out_file.write('iters xstar fa faboltz facauchy pso sa\n')
for _ in range(sample_count):
samples[0].append(f_n.iter_test(func_name, dimension_count, Population.NONE, cpu_count))
samples[1].append(f_b.iter_test(func_name, dimension_count, Population.BOLTZMANN, cpu_count))
samples[2].append(f_c.iter_test(func_name, dimension_count, Population.CAUCHY, cpu_count))
samples[3].append(pso.iter_test(func_name, dimension_count))
samples[4].append(sma.iter_test(func_name, dimension_count, iteration_count, SA.CAUCHY))
# we add 1 to count for the initial case
final = np.array([np.arange(iteration_count+1)] + [np.array([xstar]*(iteration_count + 1))] + [calc_mean(data) for data in samples])
for line in final.T:
line.toout_file(file, sep='\t')
out_file.write('\n')
except Exception as exc:
out_file.write(str(exc))
def CallbackPID(msg):
global pub
global lastTime
global pso
# print("PID Callback OK")
velX = msg.velX * 1000
velY = msg.velY * 1000
flag = msg.flag
if flag:
print("Replanned")
pso = PSO(15, 20, 1000, 1, 1, 0.5)
errorInfo.errorX = msg.errorX
errorInfo.errorY = msg.errorY
# print("INitial",velX,velY)
vX, vY = pid(velX, velY, errorInfo, pso)
# vX,vY = velX,velY
# print("Changed",vX,vY)
botAngle = msg.botAngle
# print("BotAngle ", botAngle)
vXBot = vX * cos(botAngle) + vY * sin(botAngle)
vYBot = -vX * sin(botAngle) + vY * cos(botAngle)
# print("Velocity ",vXBot,vYBot)
command_msgs = gr_Robot_Command()
final_msgs = gr_Commands()
command_msgs.id = 0
command_msgs.wheelsspeed = 0
command_msgs.veltangent = vXBot / 1000
command_msgs.velnormal = vYBot / 1000
command_msgs.velangular = 0
command_msgs.kickspeedx = 0
command_msgs.kickspeedz = 0
command_msgs.spinner = False
if (msg.velX == msg.velY and msg.velX == 0):
command_msgs.velnormal = command_msgs.veltangent = 0
# t = rospy.get_rostime()
# currTime = t.secs + t.nsecs/pow(10,9)
# diffT = float(currTime - lastTime)
# command_msgs.nextExpectedX = vXBot*diffT + homePos[0][0];
# command_msgs.nextExpectedY = vYBot*diffT + homePos[0][1];
# final_msgs.timestamp = ros::Time::now().toSec()
final_msgs.isteamyellow = False
final_msgs.robot_commands = command_msgs
# lastTime = currTime
pub.publish(final_msgs)
def train_PSO_PSO_ANN(inputs, res_ex, boundary, draw_graph=False):
dim = 9 + N_H_LAYER * 2
opso = PSO(dim,
lambda param: fitness_mean(inputs, res_ex, 50, 25,
*scale_args(param, boundary)),
max_iter=20, n_particle=10, n_neighbor=4,
inertia_start=0.5, inertia_end=0.5, comparator=minimise,
min_bound=MIN_BOUND, max_bound=MAX_BOUND)
print("\nRunning...\n")
if draw_graph:
opso.set_graph_config(inputs=inputs, res_ex=res_ex, opso=True)
opso.run()
return opso
def main():
in_data = input()
vector = list(map(float, in_data.split()))
time = vector[0]
vector.pop(0)
Searcher = PSO()
Searcher.find_minima(XSYang(vector[5:]), vector[:5], max_time=time)
for i in Searcher.best_argument():
print(i, end=" ")
print(Searcher.best_value())
def readData(self):
f = open("inputData.txt")
x=f.readline().split()
n=int(x[0])
k=int(x[1])
noIt=int(x[2])
w=float(x[3])
c1= float(x[4])
c2= float(x[5])
nSize=int(x[6])
f.close()
self._population.setSize(n,k)
self._ea.setSize(n)
self._hc.setSize(n)
self._particles.setData(n,k)
self._pso=PSO(self._particles)
self._controller.setData(noIt,k)
return (w,c1,c2,nSize)
def runtime_rastrigin():
P = generate_p(2)
start = time.time()
for i in range(0, 30):
PSO(RASTRIGIN, OPSEG_RASTRIGIN, 20, 30, 0, P, 2, False)
end = time.time()
print('PSO:', (end - start) / 30)
start = time.time()
for i in range(0, 30):
p = Populacija(RASTRIGIN, OPSEG_RASTRIGIN, 2, 1.7, 30, 0.75, 0.15, 20,
1, 20, False)
p.GenerisiGeneracije()
end = time.time()
print('GA', (end - start) / 30)
start = time.time()
for i in range(0, 30):
ACO(RASTRIGIN, OPSEG_RASTRIGIN, 20, 30, 50, 0.0001, 0.5, 2, False)
end = time.time()
print('ACO', (end - start) / 30)
def task1():
functions = ['rastrigin', 'rosenbrock', 'eggholder', 'ackley']
topologies = ['ring', 'star']
print('task1:')
total_time = time.time()
for F, T in itertools.product(functions, topologies):
print(F, T, 'time: ', end='')
t = time.time()
pso = PSO(function=F, topology=T, seed=19520624)
pso.optimize()
pso.print_log()
print(time.time() - t)
print('Total time: ', time.time() - total_time)
class Nightmare():
def __init__(self,model,cost_function,start_parameters,savename,):
self.model = model
self.cost_function = cost_function
self.start_parameters = start_parameters
self.set_PSO()
self.savename = savename
def set_PSO(self,):
self.pso = PSO()
self.pso.set_cost_function(self.cost_function)
self.pso.update_w = True
self.pso.set_start_position(self.start_parameters)
self.pso.set_bounds(1.0)
self.pso.set_speed(-0.25,0.25)
def run_pso(self,nchains,nparticles,niterations):
self.nchains = nchains
self.pso_results = []
for _ in range(nchains):
self.pso.run(nparticles,niterations)
self.pso_results.append({'params':np.asarray(self.pso.best)})
self.pso.set_start_position(self.start_parameters)
self.pso.best = None
def run_DREAM(self,nsamples=100000):
model = pymc.Model()
with model:
params = pymc.Normal('params', mu=self.start_parameters,
sd=np.array([1.0
]*len(self.start_parameters)),
shape=(len(self.start_parameters)))
#params = pymc.Flat('params',shape=(len(self.start_parameters)))
global cost_function
cost_function = self.cost_function
error = pymc.Potential('error', DREAM_cost(params))
nseedchains = 10*len(self.model.parameters_rules())
step = pymc.Dream(variables=[params],
nseedchains=nseedchains,
blocked=True,
start_random=False,
save_history=True,
parallel=True,
adapt_crossover=False,
verbose=False,)
trace = pymc.sample(nsamples, step,
start=self.pso_results,
njobs=self.nchains,
use_mpi=False,
progressbar=False,)
cont_flag = True
while cont_flag:
cont_flag = False
conv_stats = gelman_rubin(trace)
for i in conv_stats['params']:
if i>1.2:
print "Parameters have not converged, will continue run."
print "Value so far is %s"%i
cont_flag = True
break
trace = pymc.sample(int(nsamples*.1), step,
#start=self.pso_results,
njobs=self.nchains,
use_mpi=False,
trace = trace,
progressbar=False,)
conv_stats = gelman_rubin(trace)
for i in conv_stats['params']:
print i,i<1.2
#pymc.traceplot(trace,vars=[params,error])
#plt.show()
return trace
