def pso_tests():
dimension = 4
n_particles = 3
inf_limit = []
sup_limit = []
problem = pso.Problem(pso.RastriginStrategy())
for i in range(1, dimension + 1):
inf_limit.append(-i)
sup_limit.append(i)
swarm = pso.Swarm()
swarm.generate_random_swarm(n_particles, dimension, inf_limit, sup_limit)
for particle in swarm.particles:
particle.position = np.random.uniform(low=0,
high=1,
size=particle.dimension)
particle.velocity = np.random.uniform(low=0,
high=1,
size=particle.dimension)
particle.fitness = problem.calculate_fitness(particle)
pso_object = pso.PSO(1, 1, 0.5, 1, 2)
print(pso_object.calculate_inertia_component(swarm.particles[0]))
print(pso_object.calculate_memory_component(swarm.particles[0]))
print(
pso_object.calculate_cooperation_component(
swarm.particles[0],
pso_object.get_neighborhood_best_position(swarm, 0)))
pso_object.update_velocity(
swarm.particles[0],
pso_object.get_neighborhood_best_position(swarm, 0))
swarm.particles[0].print()
def run(self):
pop = self.get_pop()
solution = pso.PSO(objf=self.function,
dim=self.conf['problem']['dim'],
iters=self.conf['params']['PSO']['iterations'],
pos=pop,
Vmax=self.conf['params']['PSO']['Vmax'],
wMax=self.conf['params']['PSO']['wMax'],
wMin=self.conf['params']['PSO']['wMin'],
fopt=self.function.getfopt())
final_pop = [{
"chromosome": tuple(ind),
"id": None,
"fitness": {
"DefaultContext": 0,
"score": solution.fitness[i]
}
} for i, ind in enumerate(solution.pop)]
self.conf.update({
'iterations': solution.convergence,
'population': final_pop,
'best_individual': solution.best,
'fopt': self.function.getfopt(),
'best_score': solution.bestScore
})
if (solution.bestScore <= self.function.getfopt() + 1e-8):
self.conf['best'] = True
else:
self.conf['best'] = False
return self.conf
def goThread(self):
# get params
filename = self.getTraincomboBox.currentText()
num_iter, num_neuron = self.iterTimesSpinBox.value(), self.num_nSpinBox.value()
population = self.populationSpinBox.value()
phi1 = self.phi1doubleSpinBox.value()
phi2 = self.phi2DoubleSpinBox.value()
self.errorNumLabel.setText('Inf')
print(filename, num_iter, num_neuron, population, phi1, phi2)
# pso
self.stop_threads = False
self.pso = pso.PSO(num_iter, population, phi1, phi2, num_neuron, 1, filename)
for i in range(num_iter):
if self.stop_threads:
break
self.IterNumLabel.setText(str(i+1))
self.pso.iter()
if self.pso.BestRBFN:
self.errorNumLabel.setText('{:2.2f}'.format(self.pso.BestRBFN.error))
QtWidgets.QApplication.processEvents()
# print(self.g.BestRBFN.mu)
self.pso.BestRBFN.saveParams()
# reset getParamcomboBox
self.getParamcomboBox.clear()
comboList = os.listdir(parent+'/weights/')
self.getParamcomboBox.addItems(comboList)
self.Go.setEnabled(True)
def get_train_data(batch_size=80,
time_step=20,
train_begin=data_train_begin_1,
train_end=data_train_end):
batch_index = []
data_train = data[train_begin:train_end]
# 标准化
normalized_train_data = (
data_train - np.mean(data_train, axis=0)) / np.std(data_train, axis=0)
dim = input_size
# size = train_end - train_begin
size = rnn_unit
iter_num = 1000
x_max = 10
max_vel = 0.5
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
pso_w = tf.random_normal([input_size, rnn_unit]).eval(session=sess)
pso_b = tf.random_normal([rnn_unit, 1]).eval(session=sess)
# print(normalized_train_data[:, 0:8].shape)
# print(normalized_train_data[:, 8:9].shape)
ps = pso.PSO(pso_w, pso_b, normalized_train_data[:, 0:input_size],
normalized_train_data[:, input_size:], dim, size, iter_num,
x_max, max_vel)
fit_var_list, best_pos, new_w, new_b = ps.update()
print(pso_w)
print(new_w)
weights['in'] = tf.Variable(new_w)
biases['in'] = tf.Variable(new_b)
# 训练集
train_x, train_y = [], []
# 此时normalized_train_data的shape是n*8
for i in range(len(normalized_train_data) - time_step): # i = 1~5785
# 生成batch_index：0，batch_size*1，batch_size*2
if i % batch_size == 0:
batch_index.append(i)
x = normalized_train_data[i:i + time_step, :input_size] # x:shape 15*7
y = normalized_train_data[i:i + time_step, input_size,
np.newaxis] # y:shape 15*1
train_x.append(x.tolist())
train_y.append(y.tolist())
batch_index.append(
(len(normalized_train_data) - time_step)) # batch_index 收尾
# train_x :n*15*7
# train_y :n*15*1
return batch_index, train_x, train_y
def newPSO(param):
global psoAlg
del psoAlg
#old parameter
#step delay set to 1
#psoAlg = pso.PSO(param[0], param[1], param[2], param[3], param[4],
# param[5], param[6], param[7], 1, param[8], param[9])
#steps are set for maxSteps to adjust w
if (len(param) == 12):
#no vmax given
psoAlg = pso.PSO(param[0], param[1], param[2], param[3], param[4],
param[5], param[6], param[7], param[8], param[9],
param[10], param[11], batchParameter.steps / 3)
elif (len(param) == 13):
#vmax ratio given
psoAlg = pso.PSO(param[0], param[1], param[2], param[3], param[4],
param[5], param[6], param[7], param[8], param[9],
param[10], param[11],
batchParameter.steps / param[12])
print "using vmax =", batchParameter.steps / param[12]
def newPSO(i):
global psoAlg
del psoAlg
p = batchParameter
psoAlg = pso.PSO(p.w[i], p.wMin[i], p.c1[i], p.c2[i], p.vmaxRatio[i], p.constriction[i], p.swarmsize[i], \
p.dim[i], p.height[i], p.branches[i], p.swapDelay[i], p.function_type[i], p.noiseStyle[i], \
p.noiseSigma[i], p.swarm_type[i], p.nrScouts[i], p.maxStep[i])
psoAlg.setDynamicParameters(p.moveFrequency[i], p.moveDistance[i], p.optimumMoveStyle[i], p.updateStyle[i], \
p.detectionMethod[i], p.responseMethod[i])
psoAlg.setNoiseParameters(p.nrNoisySwapChecks[i], p.noisyReuseOldValue[i], \
p.noisyRefineBestValue[i], p.noisyFirstComparePbest[i], p.hierarchyChangeDetectThreshold[i])
psoAlg.setAdaptiveParameters(p.decreaseBranchFrequency[i], p.minBranchDegree[i],\
p.decreaseBranchStep[i], p.decreaseBranchAction[i])
def newPSO(init=False):
global p
global step
global offlineSum
offlineSum = 0
step = 0
if not (p is None):
del p
#p = pso.PSO(W, WMIN, C1, C2, VMAXRATIO, CONSTRICTION, SWARMSIZE, DIM, HEIGHT,
# BRANCHES, SWAPDELAY, OPTFUNCTION, SWARMTYPE, NR_SCOUTS, MAXSTEP)
p = pso.PSO(psoParam.w[0], psoParam.wMin[0], psoParam.c1[0], psoParam.c2[0], psoParam.vmaxRatio[0], \
psoParam.constriction[0], psoParam.swarmsize[0], psoParam.dim[0], psoParam.height[0], \
psoParam.branches[0], psoParam.swapDelay[0], psoParam.function_type[0], \
psoParam.noiseStyle[0], psoParam.noiseSigma[0],\
psoParam.swarm_type[0], psoParam.nrScouts[0], psoParam.maxStep[0])
p.setDynamicParameters(psoParam.moveFrequency[0], psoParam.moveDistance[0], \
psoParam.optimumMoveStyle[0], psoParam.updateStyle[0], psoParam.detectionMethod[0], \
psoParam.responseMethod[0])
p.setNoiseParameters(psoParam.nrNoisySwapChecks[0], psoParam.noisyReuseOldValue[0], \
psoParam.noisyRefineBestValue[0], psoParam.noisyFirstComparePbest[0], \
psoParam.hierachyChangeDetectThreshold[0])
p.setAdaptiveParameters(psoParam.decreaseBranchFrequency[0], psoParam.minBranchDegree[0],\
psoParam.decreaseBranchStep[0], psoParam.decreaseBranchAction[0])
if (init == False):
clearOpt()
clearLevel()
levelGraph.reset()
clearVel()
clearIndividualBest()
def multiplas_rodadas():
results = []
for i in range(1, 31):
print('RODADA:', i)
p = pso.PSO(c1, c2, velocidade_max, dimensao, numero_particulas,
qtd_iteracoes, TOPOLOGIA, INERCIAS, funcao)
results.append(p.optimize(w))
bests_clerc = []
bests_const = []
bests_linear = []
for result in results:
bests_clerc.append(result[0][-1])
bests_const.append(result[1][-1])
bests_linear.append(result[2][-1])
bests = [bests_clerc, bests_const, bests_linear]
df = pd.DataFrame()
import matplotlib.pyplot as plt
for i in range(len(INERCIAS)):
bests[i].sort()
df[INERCIAS[i]] = bests[i]
fig, ax = plt.subplots()
ax.set_title(f'PSO {TOPOLOGIA}-{funcao}-{INERCIAS[i]}')
ax.boxplot(bests[i])
ax.yaxis.get_major_formatter().set_scientific(False)
plt.tight_layout()
path = os.path.dirname(os.path.abspath(__file__))
path += "/boxplot"
if not os.path.exists(path):
os.mkdir(path)
path = path + '/' + dir_name
if not os.path.exists(path):
os.mkdir(path)
name_figure = f"PSO {TOPOLOGIA}-{funcao}-{INERCIAS[i]}"
plt.savefig(path + '/' + name_figure + '.png')
#plt.show()
name_figure = f"PSO {TOPOLOGIA}-{funcao}.csv"
df.to_csv(path + '/' + name_figure, index=False)
initial[0] = np.maximum(0.001, np.random.rand() * 2)
initial[1] = np.maximum(0.001, np.random.rand() * 10)
initial[2] = np.maximum(0.001, np.random.rand() * 10)
initial[3] = -1 + np.random.rand() * 2
initial[4] = np.maximum(0.001, np.random.rand() * 1)
initial[5] = -1 + np.random.rand() * 11
initial[6] = np.maximum(0.001, np.random.rand() * 1)
initial[7] = np.maximum(0.001, np.random.rand() * 1)
print(initial)
bounds = [
bound_eta, bound_kappa, bound_theta, bound_rho, bound_sig, bound_lbda,
bound_muJ, bound_sigJ
]
swarm = pso.PSO(funcMin, initial, bounds, num_particles=1000, maxiter=10)
M.parameters = np.array(swarm.best_g).reshape(-1, 1)
M.s0 = 1
M.fit(Strikes, Times, Prices, weights=M.weights)
M.parameters[3] = min(max(-1, M.parameters[3]), 1)
predictions = []
for t in np.unique(Times):
stri = Strikes[np.where(Times == t)]
c = np.random.rand(3, )
plt.scatter(stri, M.predict(stri, t), marker='+', color=c)
pri = Prices[np.where(Times == t)]
#plt.scatter(stri, pri, color = 'none', edgecolors = 'purple')
plt.scatter(stri, pri, color='none', edgecolors=c)
key = generateKey(key_size)
keyLong = vt.extendCipherText(key, int(len(toEncodeArray) / len(key)),
len(toEncodeArray))
print("ACTUAL KEY: ")
print(vt.toString(key))
cipher = vt.encrypt(keyLong, toEncodeArray)
#print(vt.toString(vt.decrypt(cipher, keyLong)))
bounds = np.tile([(0, 25)], (key_size, 1))
startTime = time.time()
psoIter = pso.PSO(pso.lossFunc,
key_size,
bounds,
cipher,
num_particles=100,
maxiter=key_size * 25)
endTime = time.time()
err_best = psoIter.getBestErr()
pos_best = psoIter.getBestPos()
numCorrect = checkSame(key, pos_best, key_size)
print("The best key was: " + vt.toString(pos_best) +
" with a loss value of " + str(err_best) +
" and a total correct of " + str(numCorrect))
csvFile = open('results.csv', 'a')
csvFile.write(
vt.toString(key) + "," + vt.toString(pos_best) + ", " +
str(err_best) + "," + str(numCorrect) + "," +
train_size = int(0.6 * X.shape[0])
valid_size = int(0.2 * X.shape[0])
X_train_tr, y_train, X_valid, y_valid, X_test_tr, y_test = X[:train_size, :], y[:train_size, :], X[
train_size:train_size +
valid_size, :], y[train_size:train_size + valid_size, :], X[
train_size + valid_size:, :], ori_values[train_size + valid_size +
window:, :]
X_train_tr = X_train_tr.T
X_test_tr = X_test_tr.T
X_valid = X_valid.T
y_train = y_train.T
y_test = y_test.T
y_valid = y_valid.T
if __name__ == '__main__':
p = pso.PSO(X_train_tr, y_train, X_valid, y_valid)
best_global_solutions = p.train(100)
maes = []
for s in best_global_solutions:
predicts = s.predict(X_test_tr)
unnorm_predicts = scaler.inverse_transform(predicts)
mae = mean_absolute_error(unnorm_predicts, y_test)
maes.append(mae)
print("MAE: %.5f" % (min(maes)))
def unica_rodada():
p = pso.PSO(c1, c2, velocidade_max, dimensao, numero_particulas,
qtd_iteracoes, TOPOLOGIA, INERCIAS, funcao)
p.optimize(w, dir_name, True)
problem = {
'CostFunction': mountain_sim,
'nVar': 3,
'VarMin':
-5, # Alternatively you can use a "numpy array" with nVar elements, instead of scalar
'VarMax':
5, # Alternatively you can use a "numpy array" with nVar elements, instead of scalar
}
env = Continuous_MountainCarEnv()
GOAL_POS = env.goal_position
# Running PSO
pso.tic()
print('Running PSO ...')
gbest, pop = pso.PSO(problem, MaxIter=200, PopSize=25)
env.close()
pso.toc()
print('Global Best:')
print(gbest)
print()
# Enjoy best
k_p = gbest["position"][0]
k_i = gbest["position"][1]
k_d = gbest["position"][2]
pid = PID(k_p, k_i, k_d, setpoint=1)
# Initilize sim
env = Continuous_MountainCarEnv()
# Define Optimization Problem
problem = {
'CostFunction': Sphere,
'nVar': 10,
'VarMin':
-5, # Alternatively you can use a "numpy array" with nVar elements, instead of scalar
'VarMax':
5, # Alternatively you can use a "numpy array" with nVar elements, instead of scalar
}
# Running PSO
pso.tic()
print('Running PSO ...')
gbest, pop = pso.PSO(problem,
MaxIter=200,
PopSize=50,
c1=1.5,
c2=2,
w=1,
wdamp=0.995)
print()
pso.toc()
print()
# Final Result
print('Global Best:')
print(gbest)
print()
Y_te = utl.scale_data(Y_te, scal_param)
# Optimize using PSO
# theta = best solution (min)
# info[0] = function value in theta
# info[1] = index of the learner with the best solution
# info[2] = number of learners close to the learner with the best solution
func = interface_PSO
args = (Xn_tr, Y_tr, learners)
theta, info = pso.PSO(func,
LB,
UB,
nPop=nPop,
epochs=epochs,
K=K,
phi=phi,
vel_fact=vel_fact,
conf_type=conf_type,
IntVar=IntVar,
normalize=normalize,
rad=rad,
args=args)
# ======= Solution ======= #
best_learner = learners[info[1]]
mu, s, c, A = best_learner.param_anfis()
print("\nSolution:")
print("J minimum = ", info[0])
print("Best learner = ", info[1])
#!/usr/bin/env/python
# -*- coding: utf-8 -*
import numpy as np
import pso
import network
swarm = pso.PSO(num=5)
print "start training"
print "each iteration will print all particles' fitness"
print "iter 1"
swarm.computeFitness()
swarm.updateGandP()
iterNum = 9
for i in range(iterNum):
print "iter %d" % (i+2)
swarm.updateVandP()
swarm.computeFitness()
swarm.updateGandP()
#store the best network into file
swarm.getBestParticle("network.json")