Arquivo de Python - Página 13 de 31

PSO com Inercia

16/07/202618/06/2026 Por antonino

O que é o PSO com inércia?

O PSO com inércia é uma evolução do PSO clássico que introduz um fator de amortecimento. Esse fator, chamado de peso de inércia (w), controla a influência da velocidade anterior. Ele foi proposto por Shi e Eberhart em 1998 para melhorar o equilíbrio exploratório. Diferentemente da versão clássica, w pode ser constante ou variar ao longo do tempo. Uma estratégia comum é reduzir w linearmente de 0.9 para 0.4 durante a execução. Isso permite exploração global no início e explotação local no final. A equação de velocidade torna-se: v = w*v + c₁*r₁*(pbest – x) + c₂*r₂*(gbest – x). O PSO com inércia é atualmente a versão mais usada em aplicações práticas. Ela oferece melhor desempenho em funções multimodais e com ruído.

Características fundamentais do PSO com inércia

O PSO com inércia possui três características distintas que o definem. Primeira, o peso w pode ser fixo (ex.: 0.7) ou dinâmico (decrescente). A inércia dinâmica é frequentemente linear: w(t) = w_max – (w_max – w_min)*(t/T). Segunda, a velocidade ainda é limitada por vmax para evitar instabilidades. Terceira, os coeficientes c₁ e c₂ permanecem constantes, geralmente iguais a 1.5. A inércia atua como um “momento” que suaviza as mudanças de direção. Isso evita oscilações bruscas e melhora a convergência para o ótimo. Além disso, a inércia reduz a dependência de condições iniciais aleatórias. O PSO com inércia é mais robusto e tolerante a erros de parametrização.

Vantagens e aplicações típicas

A principal vantagem é o controle explícito entre exploração e explotação. Com w alto, as partículas percorrem grandes regiões do espaço de busca. Com w baixo, elas refinam a solução localmente com alta precisão. Isso torna o PSO com inércia eficaz para problemas com muitos mínimos locais. Ele é amplamente usado em redes neurais, controle de processos e design ótimo. Além disso, a inércia dinâmica dispensa ajustes manuais finos. Contudo, a escolha da taxa de decaimento ainda requer alguma experimentação.

O PSO com inércia foi uma resposta às limitações da versão clássica. Estudos mostraram que w > 1 pode causar divergência do enxame. Por outro lado, w < 0.5 leva a convergência prematura e estagnação. A faixa recomendada é entre 0.4 e 0.9 para a maioria dos problemas. A redução linear é a mais popular por sua simplicidade e eficácia. Ela permite que o enxame explore amplamente no início da execução. Nas últimas iterações, as partículas se concentram ao redor do gbest. Esse comportamento mimetiza o resfriamento simulado em otimização. O PSO com inércia também pode ser combinado com técnicas de reinicialização. Por exemplo, quando o enxame estagna, w é temporariamente aumentado. Isso reintroduz diversidade sem perder as melhores soluções encontradas. A inércia também facilita a adaptação a funções com escalas diferentes. Cada dimensão pode ter seu próprio w em variantes mais avançadas. Assim, o PSO com inércia é versátil e amplamente adotado na indústria.

Um exemplo clássico é minimizar a função de Griewank em 2 dimensões. Ela tem muitos mínimos locais, mas um mínimo global em (0,0). O PSO com inércia dinâmica encontra esse ótimo com alta confiabilidade. A redução de w permite escapar de vales falsos nas primeiras iterações.

Enunciado do exemplo clássico

Implemente o PSO com inércia linearmente decrescente para minimizar a função de Griewank: f(x,y) = (x²+y²)/4000 – cos(x)*cos(y/√2) + 1, com x,y ∈ [-10, 10]. Use 30 partículas, 300 iterações, w de 0.9 a 0.4, c₁=c₂=1.5, vmax=2. Armazene o melhor fitness e a posição global a cada iteração. Plote a curva de convergência e a trajetória do gbest com contornos.

import numpy as np  
import matplotlib.pyplot as plt  

# Função de Griewank (minimização)  
def griewank(x, y):  
    return (x**2 + y**2)/4000 - np.cos(x) * np.cos(y / np.sqrt(2)) + 1  

# Parâmetros  
num_particulas = 30  
iteracoes = 300  
w_max = 0.9  
w_min = 0.4  
c1 = 1.5  
c2 = 1.5  
vmax = 2.0  
limites = [-10, 10]  
dim = 2  

# Inicialização  
posicoes = np.random.uniform(limites[0], limites[1], (num_particulas, dim))  
velocidades = np.random.uniform(-vmax, vmax, (num_particulas, dim))  
pbest_pos = posicoes.copy()  
pbest_fit = np.array([griewank(p[0], p[1]) for p in posicoes])  
gbest_idx = np.argmin(pbest_fit)  
gbest_pos = pbest_pos[gbest_idx].copy()  
gbest_fit = pbest_fit[gbest_idx]  

# Históricos  
melhor_fit_hist = [gbest_fit]  
melhor_pos_hist = [gbest_pos.copy()]  

for it in range(iteracoes):  
    # Inércia decrescente linearmente  
    w = w_max - (w_max - w_min) * (it / iteracoes)  

    for i in range(num_particulas):  
        r1, r2 = np.random.random(dim), np.random.random(dim)  
        velocidades[i] = (w * velocidades[i] +  
                          c1 * r1 * (pbest_pos[i] - posicoes[i]) +  
                          c2 * r2 * (gbest_pos - posicoes[i]))  
        velocidades[i] = np.clip(velocidades[i], -vmax, vmax)  
        posicoes[i] += velocidades[i]  
        posicoes[i] = np.clip(posicoes[i], limites[0], limites[1])  

    fit_atual = np.array([griewank(p[0], p[1]) for p in posicoes])  

    for i in range(num_particulas):  
        if fit_atual[i] < pbest_fit[i]:  
            pbest_fit[i] = fit_atual[i]  
            pbest_pos[i] = posicoes[i].copy()  

    if np.min(fit_atual) < gbest_fit:  
        gbest_idx = np.argmin(fit_atual)  
        gbest_fit = fit_atual[gbest_idx]  
        gbest_pos = posicoes[gbest_idx].copy()  

    melhor_fit_hist.append(gbest_fit)  
    melhor_pos_hist.append(gbest_pos.copy())  

print(f"Melhor fitness: {gbest_fit:.6f}")  
print(f"Melhor posição: x={gbest_pos[0]:.6f}, y={gbest_pos[1]:.6f}")  

# Gráficos  
plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.semilogy(melhor_fit_hist, 'g-', linewidth=2)  
plt.title('PSO com Inércia Decrescente - Griewank')  
plt.xlabel('Iteração')  
plt.ylabel('Melhor fitness (log)')  
plt.grid(True)  

plt.subplot(1, 2, 2)  
x_vals = np.linspace(limites[0], limites[1], 200)  
y_vals = np.linspace(limites[0], limites[1], 200)  
X, Y = np.meshgrid(x_vals, y_vals)  
Z = griewank(X, Y)  
plt.contourf(X, Y, Z, levels=50, cmap='inferno', alpha=0.7)  
plt.colorbar(label='f(x,y)')  
gbest_traj = np.array(melhor_pos_hist)  
plt.plot(gbest_traj[:,0], gbest_traj[:,1], 'w-', linewidth=1.5, alpha=0.8,  
         label='Trajetória gbest')  
plt.scatter(gbest_traj[0,0], gbest_traj[0,1], color='lime', s=80, label='Início')  
plt.scatter(gbest_traj[-1,0], gbest_traj[-1,1], color='red', s=100, label='Final')  
plt.scatter(0, 0, color='white', marker='*', s=200, label='Ótimo (0,0)')  
plt.title('Trajetória com Inércia Dinâmica')  
plt.xlabel('x')  
plt.ylabel('y')  
plt.legend()  
plt.grid(True)  
plt.tight_layout()  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

# Função de Griewank (minimização)

def griewank(x, y):

return (x**2 + y**2)/4000 - np.cos(x) * np.cos(y / np.sqrt(2)) + 1

# Parâmetros

num_particulas = 30

iteracoes = 300

w_max = 0.9

w_min = 0.4

c1 = 1.5

c2 = 1.5

vmax = 2.0

limites = [-10, 10]

dim = 2

# Inicialização

posicoes = np.random.uniform(limites[0], limites[1], (num_particulas, dim))

velocidades = np.random.uniform(-vmax, vmax, (num_particulas, dim))

pbest_pos = posicoes.copy()

pbest_fit = np.array([griewank(p[0], p[1]) for p in posicoes])

gbest_idx = np.argmin(pbest_fit)

gbest_pos = pbest_pos[gbest_idx].copy()

gbest_fit = pbest_fit[gbest_idx]

# Históricos

melhor_fit_hist = [gbest_fit]

melhor_pos_hist = [gbest_pos.copy()]

for it in range(iteracoes):

# Inércia decrescente linearmente

w = w_max - (w_max - w_min) * (it / iteracoes)

for i in range(num_particulas):

r1, r2 = np.random.random(dim), np.random.random(dim)

velocidades[i] = (w * velocidades[i] +

c1 * r1 * (pbest_pos[i] - posicoes[i]) +

c2 * r2 * (gbest_pos - posicoes[i]))

velocidades[i] = np.clip(velocidades[i], -vmax, vmax)

posicoes[i] += velocidades[i]

posicoes[i] = np.clip(posicoes[i], limites[0], limites[1])

fit_atual = np.array([griewank(p[0], p[1]) for p in posicoes])

for i in range(num_particulas):

if fit_atual[i] < pbest_fit[i]:

pbest_fit[i] = fit_atual[i]

pbest_pos[i] = posicoes[i].copy()

if np.min(fit_atual) < gbest_fit:

gbest_idx = np.argmin(fit_atual)

gbest_fit = fit_atual[gbest_idx]

gbest_pos = posicoes[gbest_idx].copy()

melhor_fit_hist.append(gbest_fit)

melhor_pos_hist.append(gbest_pos.copy())

print(f"Melhor fitness: {gbest_fit:.6f}")

print(f"Melhor posição: x={gbest_pos[0]:.6f}, y={gbest_pos[1]:.6f}")

# Gráficos

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.semilogy(melhor_fit_hist, 'g-', linewidth=2)

plt.title('PSO com Inércia Decrescente - Griewank')

plt.xlabel('Iteração')

plt.ylabel('Melhor fitness (log)')

plt.grid(True)

plt.subplot(1, 2, 2)

x_vals = np.linspace(limites[0], limites[1], 200)

y_vals = np.linspace(limites[0], limites[1], 200)

X, Y = np.meshgrid(x_vals, y_vals)

Z = griewank(X, Y)

plt.contourf(X, Y, Z, levels=50, cmap='inferno', alpha=0.7)

plt.colorbar(label='f(x,y)')

gbest_traj = np.array(melhor_pos_hist)

plt.plot(gbest_traj[:,0], gbest_traj[:,1], 'w-', linewidth=1.5, alpha=0.8,

label='Trajetória gbest')

plt.scatter(gbest_traj[0,0], gbest_traj[0,1], color='lime', s=80, label='Início')

plt.scatter(gbest_traj[-1,0], gbest_traj[-1,1], color='red', s=100, label='Final')

plt.scatter(0, 0, color='white', marker='*', s=200, label='Ótimo (0,0)')

plt.title('Trajetória com Inércia Dinâmica')

plt.xlabel('x')

plt.ylabel('y')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

Este código implementa o PSO com inércia linearmente decrescente. A curva de convergência mostra uma queda suave e consistente do erro. A trajetória do gbest revela exploração ampla no início e refinamento no final. A inércia dinâmica permite escapar de mínimos locais da função Griewank. Para iniciantes, este exemplo demonstra o poder do controle adaptativo. O PSO com inércia é, portanto, uma ferramenta madura e confiável.

PSO Classico

16/07/202618/06/2026 Por antonino

O que é o PSO clássico?

O PSO clássico é a versão original do algoritmo de otimização por enxame de partículas. Ele foi proposto por Kennedy e Eberhart em 1995 sem modificações posteriores. Nesta versão, cada partícula tem posição, velocidade e memória individual. A velocidade é atualizada usando inércia constante, sem coeficientes adaptativos. Os parâmetros w, c₁ e c₂ são fixos durante toda a execução. Não há mecanismos de turbulência ou reinicialização para escapar de ótimos locais. O gbest é a melhor posição encontrada por qualquer partícula até o momento. O pbest é a melhor posição que cada partícula já visitou individualmente. A equação de velocidade é: v = w*v + c₁*r₁*(pbest – x) + c₂*r₂*(gbest – x). Essa formulação simples é a base de todas as variantes modernas do PSO.

Características essenciais do PSO clássico

O PSO clássico tem três características marcantes que o definem. Primeira, ele opera com um enxame de tamanho fixo, tipicamente entre 20 e 50. Segunda, a inércia w é constante (geralmente 0.7 a 0.9) durante todo o processo. Terceira, os coeficientes cognitivo (c₁) e social (c₂) são iguais (≈ 1.5 a 2.0). Não há evaporação, seleção ou crossover como em algoritmos genéticos. A atualização é puramente baseada em equações diferenciais estocásticas. Além disso, o PSO clássico não usa restrições de velocidade máxima (vmax). Contudo, muitas implementações incluem clamping para evitar explosão das partículas. O critério de parada é geralmente um número fixo de iterações ou tolerância. Essa simplicidade torna o PSO clássico fácil de programar e entender.

Vantagens e limitações da versão clássica

A principal vantagem é a convergência rápida em funções unimodais e suaves. Ela também requer poucos parâmetros e nenhum conhecimento prévio do problema. Por outro lado, o PSO clássico sofre com convergência prematura em funções multimodais. Ele tende a estagnar em mínimos locais porque a inércia não é ajustada. Além disso, a falta de diversidade populacional reduz a capacidade de exploração. Para superar isso, variantes com inércia adaptativa ou enxames hierárquicos surgiram. Ainda assim, o PSO clássico é um excelente ponto de partida para iniciantes.

O PSO clássico foi inicialmente testado em funções de referência como Sphere e Rastrigin. Ele mostrou desempenho superior a algoritmos genéticos em problemas contínuos. A simplicidade matemática permitiu análises teóricas de convergência. Estudos mostraram que o enxame converge para o gbest se os parâmetros forem bem escolhidos. A inércia w controla o trade-off entre exploração global e explotação local. Valores altos de w (próximos a 1) incentivam movimentos amplos e diversidade. Valores baixos (próximos a 0) fazem as partículas se concentrarem ao redor do gbest. Os coeficientes c₁ e c₂ determinam a atração para pbest e gbest, respectivamente. Quando c₁ > c₂, as partículas confiam mais em sua própria experiência. Quando c₂ > c₁, elas seguem o enxame de forma mais coletiva. O equilíbrio clássico c₁ = c₂ = 1.5 produz resultados robustos na maioria dos casos. O PSO clássico não tem mecanismo de reinicialização, o que é uma desvantagem. Porém, sua transparência facilita a depuração e o ajuste manual. Assim, o PSO clássico é uma ferramenta didática e funcional para otimização.

Um exemplo clássico é minimizar a função de Rosenbrock em 2 dimensões. Seu vale estreito e curvo desafia algoritmos baseados em gradiente. O PSO clássico encontra o mínimo (1,1) com precisão razoável. A inércia constante permite que as partículas oscilem até se estabilizar.

Enunciado do exemplo clássico

Implemente o PSO clássico para minimizar a função de Rosenbrock em 2D: f(x,y) = (1-x)² + 100*(y-x²)², com x,y ∈ [-2, 2]. Use 25 partículas, 300 iterações, w=0.8, c₁=c₂=1.5, e vmax = 0.5 por dimensão. Armazene o melhor fitness e a posição global a cada iteração. Plote a curva de convergência e a trajetória do gbest no espaço 2D com contornos.

import numpy as np  
import matplotlib.pyplot as plt  

# Função de Rosenbrock (minimização)  
def rosenbrock(x, y):  
    return (1 - x)**2 + 100 * (y - x**2)**2  

# Parâmetros PSO clássico  
num_particulas = 25  
iteracoes = 300  
w = 0.8  
c1 = 1.5  
c2 = 1.5  
vmax = 0.5  
limites = [-2, 2]  
dim = 2  

# Inicialização  
posicoes = np.random.uniform(limites[0], limites[1], (num_particulas, dim))  
velocidades = np.random.uniform(-vmax, vmax, (num_particulas, dim))  
pbest_pos = posicoes.copy()  
pbest_fit = np.array([rosenbrock(p[0], p[1]) for p in posicoes])  
gbest_idx = np.argmin(pbest_fit)  
gbest_pos = pbest_pos[gbest_idx].copy()  
gbest_fit = pbest_fit[gbest_idx]  

# Históricos  
melhor_fit_hist = [gbest_fit]  
melhor_pos_hist = [gbest_pos.copy()]  

for it in range(iteracoes):  
    for i in range(num_particulas):  
        r1, r2 = np.random.random(dim), np.random.random(dim)  
        # Atualização clássica  
        velocidades[i] = (w * velocidades[i] +  
                          c1 * r1 * (pbest_pos[i] - posicoes[i]) +  
                          c2 * r2 * (gbest_pos - posicoes[i]))  
        # Clamping da velocidade  
        velocidades[i] = np.clip(velocidades[i], -vmax, vmax)  
        posicoes[i] += velocidades[i]  
        posicoes[i] = np.clip(posicoes[i], limites[0], limites[1])  

    # Avaliação  
    fit_atual = np.array([rosenbrock(p[0], p[1]) for p in posicoes])  

    # Atualizar pbest  
    for i in range(num_particulas):  
        if fit_atual[i] < pbest_fit[i]:  
            pbest_fit[i] = fit_atual[i]  
            pbest_pos[i] = posicoes[i].copy()  

    # Atualizar gbest  
    if np.min(fit_atual) < gbest_fit:  
        gbest_idx = np.argmin(fit_atual)  
        gbest_fit = fit_atual[gbest_idx]  
        gbest_pos = posicoes[gbest_idx].copy()  

    melhor_fit_hist.append(gbest_fit)  
    melhor_pos_hist.append(gbest_pos.copy())  

print(f"Melhor fitness: {gbest_fit:.6f}")  
print(f"Melhor posição: x={gbest_pos[0]:.6f}, y={gbest_pos[1]:.6f}")  

# Gráficos  
plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.plot(melhor_fit_hist, 'b-', linewidth=2)  
plt.title('Convergência - PSO Clássico na Rosenbrock')  
plt.xlabel('Iteração')  
plt.ylabel('Melhor fitness')  
plt.grid(True)  

plt.subplot(1, 2, 2)  
# Contornos  
x_vals = np.linspace(limites[0], limites[1], 200)  
y_vals = np.linspace(limites[0], limites[1], 200)  
X, Y = np.meshgrid(x_vals, y_vals)  
Z = rosenbrock(X, Y)  
plt.contourf(X, Y, Z, levels=50, cmap='plasma', alpha=0.7)  
plt.colorbar(label='f(x,y)')  
# Trajetória do gbest  
gbest_traj = np.array(melhor_pos_hist)  
plt.plot(gbest_traj[:,0], gbest_traj[:,1], 'w-', linewidth=1.5, alpha=0.8,  
         label='Trajetória do gbest')  
plt.scatter(gbest_traj[0,0], gbest_traj[0,1], color='lime', s=80, label='Início')  
plt.scatter(gbest_traj[-1,0], gbest_traj[-1,1], color='red', s=100, label='Final')  
plt.scatter(1, 1, color='white', marker='*', s=200, label='Ótimo (1,1)')  
plt.title('Trajetória do Melhor Global - PSO Clássico')  
plt.xlabel('x')  
plt.ylabel('y')  
plt.legend()  
plt.grid(True)  
plt.tight_layout()  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

# Função de Rosenbrock (minimização)

def rosenbrock(x, y):

return (1 - x)**2 + 100 * (y - x**2)**2

# Parâmetros PSO clássico

num_particulas = 25

iteracoes = 300

w = 0.8

c1 = 1.5

c2 = 1.5

vmax = 0.5

limites = [-2, 2]

dim = 2

# Inicialização

posicoes = np.random.uniform(limites[0], limites[1], (num_particulas, dim))

velocidades = np.random.uniform(-vmax, vmax, (num_particulas, dim))

pbest_pos = posicoes.copy()

pbest_fit = np.array([rosenbrock(p[0], p[1]) for p in posicoes])

gbest_idx = np.argmin(pbest_fit)

gbest_pos = pbest_pos[gbest_idx].copy()

gbest_fit = pbest_fit[gbest_idx]

# Históricos

melhor_fit_hist = [gbest_fit]

melhor_pos_hist = [gbest_pos.copy()]

for it in range(iteracoes):

for i in range(num_particulas):

r1, r2 = np.random.random(dim), np.random.random(dim)

# Atualização clássica

velocidades[i] = (w * velocidades[i] +

c1 * r1 * (pbest_pos[i] - posicoes[i]) +

c2 * r2 * (gbest_pos - posicoes[i]))

# Clamping da velocidade

velocidades[i] = np.clip(velocidades[i], -vmax, vmax)

posicoes[i] += velocidades[i]

posicoes[i] = np.clip(posicoes[i], limites[0], limites[1])

# Avaliação

fit_atual = np.array([rosenbrock(p[0], p[1]) for p in posicoes])

# Atualizar pbest

for i in range(num_particulas):

if fit_atual[i] < pbest_fit[i]:

pbest_fit[i] = fit_atual[i]

pbest_pos[i] = posicoes[i].copy()

# Atualizar gbest

if np.min(fit_atual) < gbest_fit:

gbest_idx = np.argmin(fit_atual)

gbest_fit = fit_atual[gbest_idx]

gbest_pos = posicoes[gbest_idx].copy()

melhor_fit_hist.append(gbest_fit)

melhor_pos_hist.append(gbest_pos.copy())

print(f"Melhor fitness: {gbest_fit:.6f}")

print(f"Melhor posição: x={gbest_pos[0]:.6f}, y={gbest_pos[1]:.6f}")

# Gráficos

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.plot(melhor_fit_hist, 'b-', linewidth=2)

plt.title('Convergência - PSO Clássico na Rosenbrock')

plt.xlabel('Iteração')

plt.ylabel('Melhor fitness')

plt.grid(True)

plt.subplot(1, 2, 2)

# Contornos

x_vals = np.linspace(limites[0], limites[1], 200)

y_vals = np.linspace(limites[0], limites[1], 200)

X, Y = np.meshgrid(x_vals, y_vals)

Z = rosenbrock(X, Y)

plt.contourf(X, Y, Z, levels=50, cmap='plasma', alpha=0.7)

plt.colorbar(label='f(x,y)')

# Trajetória do gbest

gbest_traj = np.array(melhor_pos_hist)

plt.plot(gbest_traj[:,0], gbest_traj[:,1], 'w-', linewidth=1.5, alpha=0.8,

label='Trajetória do gbest')

plt.scatter(gbest_traj[0,0], gbest_traj[0,1], color='lime', s=80, label='Início')

plt.scatter(gbest_traj[-1,0], gbest_traj[-1,1], color='red', s=100, label='Final')

plt.scatter(1, 1, color='white', marker='*', s=200, label='Ótimo (1,1)')

plt.title('Trajetória do Melhor Global - PSO Clássico')

plt.xlabel('x')

plt.ylabel('y')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

Este código implementa o PSO clássico com clamping de velocidade. A curva de convergência mostra uma redução estável do erro ao longo do tempo. A trajetória do gbest revela como o enxame se move pelo vale da Rosenbrock. Mesmo com parâmetros fixos, o algoritmo encontra uma boa aproximação do ótimo. Para iniciantes, este exemplo demonstra a eficácia da formulação original. O PSO clássico é, portanto, um algoritmo fundamental e atemporal.