22/02/2024, 09:32 PSO_definicao_e_exemplos.

ipynb - Colaboratory

Universidade Federal Do Amapá – UNIFAP

Departamento de Ciência Exatas e Tecnologia – DCET

Coordenação do Curso de Engenharia Elétrica - CEE

Capacitação profissional para aperfeiçoamento/desenvolvimento de recursos humanos em Inteligência Artificial com foco no
desenvolvimento da Amazônia

PSO - Particle Swarm Optimization (Otimização por Enxame de Partículas)

Prof. Dr. Marcelo Ricardo Souza Siqueira

1. A Particle Swarm Optimization (PSO) é um algoritmo de otimização inspirado no comportamento social de enxames de pássaros,
cardumes de peixes ou outros sistemas sociais naturais. Ele foi proposto por James Kennedy e Russell Eberhart em 1995. O PSO é
utilizado para otimização global e é particularmente eficaz em espaços de busca complexos.

2. O algoritmo PSO funciona simulando o comportamento de pássaros em busca de alimentos. Cada possível solução é representada por
uma partícula no espaço de busca. As partículas movem-se pelo espaço de busca ajustando sua posição e velocidade com base no
desempenho da solução. A ideia é que, ao longo do tempo, as partículas convergirão para uma solução ótima.

Exemplo 1: implementação básica do algoritmo Particle Swarm Optimization (PSO) em Python. O objetivo desse código é otimizar uma
função objetivo simples, chamada de objective_function. Neste caso, a função objetivo é a soma dos quadrados dos elementos de um vetor
x. A intenção é mostrar como o PSO pode ser utilizado para encontrar o mínimo global dessa função, considerando um espaço de busca
definido pelo intervalo (-5.12, 5.12) para cada dimensão.

A estrutura do código segue o fluxo típico do PSO, com a inicialização de partículas em posições e velocidades aleatórias, a atualização
iterativa das posições com base em fatores como inércia, experiência pessoal (cognitiva) e experiência global (social), e a avaliação da
função objetivo para determinar quão boas são as soluções.

Embora a função objetivo seja simples, a ideia é fornecer uma implementação clara e compreensível do PSO em um contexto genérico. Em
aplicações práticas, a função objetivo seria substituída por uma que represente o problema específico que se deseja otimizar (por exemplo,
otimização de parâmetros em um modelo complexo, otimização de trajetória, etc.).

1 # Exemplo1. PSO básico

2
3 #1. Aqui, importamos a biblioteca NumPy para lidar com operações numéricas e
4 # definimos uma função objetivo simples, que é a soma dos quadrados dos elementos
5 # de um vetor x. Esta função pode ser substituída por qualquer função que você
6 # deseja otimizar.
7
8 import numpy as np
9
10 def objective_function(x):
11 """Função objetivo de exemplo."""
12 return sum(x**2)
13
14 # Aqui, definimos a função particle_swarm_optimization que implementa o algoritmo PSO.
15 # As partículas são inicializadas aleatoriamente no espaço de busca definido
16 # por (-5.12, 5.12) para cada dimensão. As velocidades das partículas também são
17 # inicializadas aleatoriamente. As posições e valores pessoais iniciais são definidos
18 # com base na posição inicial. O índice da melhor partícula global é calculado.
19
20 def particle_swarm_optimization(objective_function, num_dimensions, num_particles, max_iterations):
21 # Inicialização
22 particles_position = np.random.uniform(-5.12, 5.12, size=(num_particles, num_dimensions))
23 particles_velocity = np.random.rand(num_particles, num_dimensions)
24 personal_best_position = particles_position.copy()
25 personal_best_value = np.array([objective_function(p) for p in particles_position])
26 global_best_index = np.argmin(personal_best_value)
27 global_best_position = personal_best_position[global_best_index, :]
28
29 # Aqui, definimos os parâmetros do PSO, incluindo o peso da inércia (inertia_weight),
30 # peso cognitivo (cognitive_weight), e peso social (social_weight).
31
32 # Parâmetros do PSO
33 inertia_weight = 0.7
34 cognitive_weight = 1.5
35 social_weight = 1.5
36
37 # Neste bloco, ocorrem as iterações do PSO. As posições e velocidades das partículas
38 # são atualizadas de acordo com as fórmulas do algoritmo. O movimento é influenciado
39 l i é i iê i l i i iê i l b l i l
https://colab.research.google.com/drive/10tgxwEsgQHN8zYh1LCb1I1ZztmNJGtL7?authuser=1#scrollTo=VzRXRCr3-t9D&printMode=true 1/6
22/02/2024, 09:32 PSO_definicao_e_exemplos.ipynb - Colaboratory
39 # pela inércia, experiência pessoal (cognitiva) e experiência global (social).
40
41 # Iterações
42 for iteration in range(max_iterations):
43 # Atualização da posição e velocidade
44 r1, r2 = np.random.rand(num_particles, num_dimensions), np.random.rand(num_particles, num_dimensions)
45 particles_velocity = (inertia_weight * particles_velocity +
46 cognitive_weight * r1 * (personal_best_position - particles_position) +
47 social_weight * r2 * (global_best_position - particles_position))
48 particles_position += particles_velocity
49
50 # Aqui, calculamos os valores atuais da função objetivo para cada partícula e atualizamos os melhores
51 # valores pessoais e globais, bem como suas posições correspondentes.
52
53 # Avaliação da função objetivo
54 current_value = np.array([objective_function(p) for p in particles_position])
55
56 # Finalmente, o código retorna a melhor posição encontrada e o valor da função objetivo correspondente.
57
58 # Atualização do melhor valor pessoal e global
59 update_personal_best = current_value < personal_best_value
60 personal_best_position[update_personal_best] = particles_position[update_personal_best]
61 personal_best_value[update_personal_best] = current_value[update_personal_best]
62
63 global_best_index = np.argmin(personal_best_value)
64 global_best_position = personal_best_position[global_best_index, :]
65
66 return global_best_position, objective_function(global_best_position)
67
68 # Neste bloco final, é feito um exemplo de uso do PSO com a função objetivo definida.
69 # Os resultados são impressos na tela. Este código é um ponto de partida básico e pode
70 # ser ajustado conforme necessário para diferentes problemas de otimização.
71
72 # Exemplo de uso
73 num_dimensions = 2
74 num_particles = 30
75 max_iterations = 100
76 best_solution, best_value = particle_swarm_optimization(objective_function, num_dimensions, num_particles, max_iteratio
77
78 print("Melhor solução encontrada:", best_solution)
79 print("Valor da função objetivo:", best_value)
80
81

output Melhor solução encontrada: [2.30360835e-07 2.02679907e-07]

Valor da função objetivo: 9.414525898902981e-14

Exemplo 2: PSO para otimizar os parâmetros de um modelo de regressão linear. O objetivo será ajustar os coeficientes do modelo de
regressão para minimizar o erro quadrático médio em um conjunto de dados.

Neste exemplo, criamos dados de exemplo com um modelo linear conhecido (com ruído adicionado). A função objetivo do PSO busca
minimizar o erro quadrático médio ajustando os parâmetros a e b da regressão linear. O PSO é aplicado para encontrar os melhores valores
de a e b que minimizam o erro.

https://colab.research.google.com/drive/10tgxwEsgQHN8zYh1LCb1I1ZztmNJGtL7?authuser=1#scrollTo=VzRXRCr3-t9D&printMode=true 2/6
22/02/2024, 09:32 PSO_definicao_e_exemplos.ipynb - Colaboratory
1 # Exemplo 2 - regressão linear
2
3 #import numpy as np
4 import matplotlib.pyplot as plt
5
6 # Função objetivo: Regressão linear com dois parâmetros (a e b)
7 def linear_regression(x, a, b):
8 return a * x + b
9
10 # Função de erro: Erro quadrático médio
11 def mean_squared_error(y_true, y_pred):
12 return np.mean((y_true - y_pred)**2)
13
14 # Função objetivo para o PSO: Minimizar o erro quadrático médio
15 def objective_function1(params):
16 a, b = params
17 y_pred = linear_regression(x_data, a, b)
18 return mean_squared_error(y_data, y_pred)
19
20 # Dados de exemplo
21 np.random.seed(42)
22 x_data = np.sort(5 * np.random.rand(50))
23 y_data = 2 * x_data - 1 + np.random.randn(50)
24
25 # Aplicando PSO para encontrar os melhores parâmetros da regressão linear
26 num_dimensions = 2
27 num_particles = 30
28 max_iterations = 100
29
30 best_solution, best_value = particle_swarm_optimization(objective_function1, num_dimensions, num_particles, max_itera
31
32 # Resultados
33 best_a, best_b = best_solution
34 print("Melhores parâmetros encontrados:")
35 print("a:", best_a)
36 print("b:", best_b)
37
38 # Visualização
39 plt.scatter(x_data, y_data, label='Dados reais')
40 plt.plot(x_data, linear_regression(x_data, best_a, best_b), color='red', label='Regressão Linear Ajustada')
41 plt.legend()
42 plt.xlabel('X')
43 plt.ylabel('Y')
44 plt.title('Regressão Linear com PSO')
45 plt.show()
46

Melhores parâmetros encontrados:

a: 2.034800292628378
b: -1.0805354107626346

Exemplo 3: Particle Swarm Optimization (PSO) para otimizar os parâmetros de um modelo de ajuste de curva. Neste caso, usaremos o PSO
para ajustar os parâmetros de uma função senoidal a dados experimentais ruidosos.

https://colab.research.google.com/drive/10tgxwEsgQHN8zYh1LCb1I1ZztmNJGtL7?authuser=1#scrollTo=VzRXRCr3-t9D&printMode=true 3/6
22/02/2024, 09:32 PSO_definicao_e_exemplos.ipynb - Colaboratory
1 # import numpy as np
2 # import matplotlib.pyplot as plt
3
4 # Função objetivo: Seno + ruído
5 def objective_function2(params):
6 A, f, phi = params
7 y_pred = A * np.sin(f * x_data + phi)
8 return np.mean((y_data - y_pred)**2)
9
10 # Dados de exemplo
11 np.random.seed(42)
12 x_data = np.linspace(0, 2 * np.pi, 100)
13 y_data = 3 * np.sin(2 * x_data - 1.5) + np.random.normal(0, 0.5, size=len(x_data))
14
15 # Aplicando PSO para ajustar os parâmetros da função senoidal
16 num_dimensions = 3 # A, f, phi
17 num_particles = 30
18 max_iterations = 100
19
20 best_solution, best_value = particle_swarm_optimization(objective_function2, num_dimensions, num_particles, max_itera
21
22 # Resultados
23 best_A, best_f, best_phi = best_solution
24 print("Melhores parâmetros encontrados:")
25 print("Amplitude (A):", best_A)
26 print("Frequência (f):", best_f)
27 print("Fase (phi):", best_phi)
28
29 # Visualização
30 plt.scatter(x_data, y_data, label='Dados reais')
31 plt.plot(x_data, best_A * np.sin(best_f * x_data + best_phi), color='red', label='Ajuste Senoidal')
32 plt.legend(loc='upper left')
33 plt.xlabel('X')
34 plt.ylabel('Y')
35 plt.title('Ajuste Senoidal com PSO')
36 plt.show()
37

Melhores parâmetros encontrados:

Amplitude (A): 2.953512057803517
Frequência (f): -2.0103486921805884
Fase (phi): 4.663114953816018

https://colab.research.google.com/drive/10tgxwEsgQHN8zYh1LCb1I1ZztmNJGtL7?authuser=1#scrollTo=VzRXRCr3-t9D&printMode=true 4/6
22/02/2024, 09:32 PSO_definicao_e_exemplos.ipynb - Colaboratory
1 import numpy as np
2 import matplotlib.pyplot as plt
3 from scipy.integrate import quad
4 from scipy.optimize import minimize_scalar
5 from scipy.special import ellipk, ellipe
6
7 # Função da braquistócrona paramétrica
8 def brachistochrone(t, a):
9 y = -a * (1 - np.cos(t))
10 x = a * (t - np.sin(t))
11 return x, y
12
13 # Função do integrando para o cálculo do tempo de queda
14 def integrand(t, a):
15 return np.sqrt((1 + (np.sin(t / 2) ** 2)) / (2 * g * a * (1 - np.cos(t))))
16
17 # Função objetivo a ser minimizada (tempo total de queda)
18 def objective_function_brachistochrone(a):
19 result, _ = quad(integrand, 0, np.pi, args=(a,))
20 return result
21
22 # Pontos inicial e final
23 x0, y0 = 0, 0
24 x1, y1 = 5, -5
25
26 # Aceleração devida à gravidade
27 g = -9.8
28
29 # Executando a otimização para encontrar o parâmetro 'a'
30 result = minimize_scalar(objective_function_brachistochrone, bounds=(0, 10), method='bounded')
31
32 # Melhor parâmetro 'a' encontrado
33 best_a = result.x
34 print("Melhor parâmetro 'a' encontrado:", best_a)
35
36 # Visualização da trajetória da braquistócrona
37 t_values = np.linspace(0, np.pi, 100)
38 x_values, y_values = brachistochrone(t_values, best_a)
39
40 plt.plot(x_values, y_values, label='Braquistócrona Otimizada')
41 plt.scatter([x0, x1], [y0, y1], color='red', label='Pontos Inicial e Final')
42 plt.title('Braquistócrona - Trajetória Otimizada')
43 plt.xlabel('x')
44 plt.ylabel('y')
45 plt.grid()
46 plt.legend()
47 plt.show()
48

<ipython-input-4-9be87a4f1266>:15: RuntimeWarning: invalid value encountered i

return np.sqrt((1 + (np.sin(t / 2) ** 2)) / (2 * g * a * (1 - np.cos(t))))
<ipython-input-4-9be87a4f1266>:19: IntegrationWarning: The occurrence of round
the requested tolerance from being achieved. The error may be
underestimated.
result, _ = quad(integrand, 0, np.pi, args=(a,))
Melhor parâmetro 'a' encontrado: 3.819660112501051

https://colab.research.google.com/drive/10tgxwEsgQHN8zYh1LCb1I1ZztmNJGtL7?authuser=1#scrollTo=VzRXRCr3-t9D&printMode=true 5/6
22/02/2024, 09:32 PSO_definicao_e_exemplos.ipynb - Colaboratory

1 import numpy as np
2
3 def pso(funcao_objetivo, n_particulas, n_iteracao,
4 min_x, max_x, v_min, v_max):
5
6 # Inércia (peso da velocidade anterior)
7 w = 0.7298
8
9 # Fatores de aprendizado cognitivo e social
10 c1 = 1.49618
11 c2 = 1.49618
12
13 # Inicialização das partículas
14 particulas = np.random.uniform(min_x, max_x, (n_particulas, dimensao))
15 velocidades = np.random.uniform(v_min, v_max, (n_particulas, dimensao))
16 pbest = particulas.copy()
17 gbest = np.min(pbest, axis=0)
18
19 # Loop principal
20 for iteracao in range(n_iteracao):
21 for i in range(n_particulas):
22 # Atualização da velocidade
23 velocidades[i] = w * velocidades[i] + c1 * np.random.rand() * (pbest[i] - particulas[i]) + c2 * np.random
24 # Atualização da posição
25 particulas[i] += velocidades[i]
26
27 # Avaliação da função objetivo
28 valor_objetivo = funcao_objetivo(particulas[i])
29
30 # Atualização da melhor posição individual
31 if valor_objetivo < funcao_objetivo(pbest[i]):
32 pbest[i] = particulas[i]
33
34 # Atualização da melhor posição global
35 if valor_objetivo < funcao_objetivo(gbest):
36 gbest = particulas[i]
37
38 return gbest
39
40 # Definindo a função objetivo
41 def funcao_objetivo(x):
42 return (x[0] - 5)**2 + (x[1] - 5)**2
43
44 # Parâmetros do PSO
45 n_particulas = 100

https://colab.research.google.com/drive/10tgxwEsgQHN8zYh1LCb1I1ZztmNJGtL7?authuser=1#scrollTo=VzRXRCr3-t9D&printMode=true 6/6