Arquivo de Python - Página 14 de 31

Otimizacao por Enxame de Particulas (PSO)

16/07/202618/06/2026 Por antonino

O que é a otimização por enxame de partículas?

A otimizaçao por enxame de partículas (PSO) é um algoritmo meta-heurístico inspirado no comportamento social. Ela foi proposta por Kennedy e Eberhart em 1995, simulando bandos de pássaros ou cardumes. Cada partícula representa uma solução candidata no espaço de busca contínuo. Essas partículas voam pelo espaço ajustando suas posições com base em duas referências. A primeira é a melhor posição que a própria partícula já visitou (memória individual). A segunda é a melhor posição encontrada por qualquer partícula do enxame (memória social). A combinação dessas influências guia o enxame em direção ao ótimo global. Diferentemente dos algoritmos genéticos, o PSO não usa seleção ou crossover. Ele é simples, rápido e requer poucos parâmetros para ser configurado. Portanto, o PSO é uma ferramenta popular para otimização contínua e multimodal.

Características fundamentais do PSO

O PSO possui três características principais que definem seu comportamento. Primeiro, cada partícula tem uma posição (x) e uma velocidade (v) no espaço. A velocidade é atualizada usando uma equação com três componentes: inércia, cognitiva e social. O componente inercial mantém a direção anterior, evitando mudanças bruscas. O componente cognitivo puxa a partícula em direção ao seu melhor histórico pessoal (pbest). O componente social a atrai para a melhor posição global do enxame (gbest). Dois coeficientes (c₁ e c₂) controlam a força de cada componente. Além disso, números aleatórios introduzem estocasticidade para explorar novas regiões. Segundo, o PSO não tem operadores de mutação ou recombinação. Terceiro, ele é completamente paralelizável, pois cada partícula é independente. Essas características tornam o PSO eficiente e fácil de implementar.

Vantagens e aplicações típicas

O PSO é amplamente usado em engenharia, finanças e aprendizado de máquina. Ele é excelente para funções contínuas com muitas variáveis e mínimos locais. Uma grande vantagem é a convergência rápida nas primeiras iterações. Além disso, ele requer pouca memória e é facilmente adaptável a restrições. Contudo, o PSO pode convergir prematuramente para ótimos locais em alguns casos. Para evitar isso, variantes com inércia adaptativa ou enxames multi-objetivo foram criadas. Ainda assim, o PSO é uma das meta-heurísticas mais usadas na indústria.

A dinâmica do PSO é governada por equações de atualização simples. A velocidade é calculada como: v(t+1) = w*v(t) + c₁*r₁*(pbest – x) + c₂*r₂*(gbest – x). A posição é atualizada por: x(t+1) = x(t) + v(t+1). O parâmetro w (inércia) controla o equilíbrio entre exploração e explotação. Valores altos de w incentivam a busca global; valores baixos refinam a busca local. Os coeficientes c₁ e c₂ geralmente são iguais (≈ 1.5 a 2.0) para equilíbrio. As variáveis r₁ e r₂ são números aleatórios uniformes entre 0 e 1. O pbest é atualizado sempre que a partícula encontra uma posição melhor. O gbest é atualizado quando qualquer partícula supera o melhor global atual. Esse mecanismo simples produz um comportamento emergente surpreendente. O enxame converge para o mínimo (ou máximo) sem controle centralizado. O PSO também pode ser usado para problemas com restrições usando penalidades. Ele é frequentemente comparado a algoritmos genéticos e estratégias evolutivas. Assim, o PSO é uma abordagem elegante e poderosa para otimização.

Um exemplo clássico é minimizar a função de Rastrigin em 2 dimensões. Ela tem muitos mínimos locais, mas o mínimo global está em (0,0). O PSO encontra esse ponto com alta precisão após algumas dezenas de iterações. A inércia e os componentes social/cognitivo guiam as partículas até o vale central.

Enunciado do exemplo clássico

Implemente o PSO para minimizar a função de Ackley em 2 dimensões: f(x,y) = -20*exp(-0.2*sqrt(0.5*(x²+y²))) – exp(0.5*(cos(2πx)+cos(2πy))) + 20 + e, com domínio [-5,5]. Use 30 partículas, 200 iterações, w=0.7, c₁=c₂=1.5. Armazene o melhor fitness global e a posição correspondente a cada iteração. Plote a curva de convergência e a trajetória de todas as partículas no plano 2D (com contornos).

import numpy as np  
import matplotlib.pyplot as plt  

# Função de Ackley (minimização)  
def ackley(x, y):  
    term1 = -20 * np.exp(-0.2 * np.sqrt(0.5 * (x**2 + y**2)))  
    term2 = -np.exp(0.5 * (np.cos(2*np.pi*x) + np.cos(2*np.pi*y)))  
    return term1 + term2 + 20 + np.e  

# Parâmetros PSO  
num_particulas = 30  
iteracoes = 200  
w = 0.7  
c1 = 1.5  
c2 = 1.5  
limites = [-5, 5]  
dim = 2  

# Inicialização  
posicoes = np.random.uniform(limites[0], limites[1], (num_particulas, dim))  
velocidades = np.random.uniform(-1, 1, (num_particulas, dim))  
pbest_pos = posicoes.copy()  
pbest_fit = np.array([ackley(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()]  
trajetorias = [posicoes.copy()]  

for it in range(iteracoes):  
    # Atualizar velocidade e posição  
    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]))  
        posicoes[i] += velocidades[i]  
        posicoes[i] = np.clip(posicoes[i], limites[0], limites[1])  

    # Avaliar nova aptidão  
    fit_atual = np.array([ackley(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())  
    trajetorias.append(posicoes.copy())  

print(f"Melhor fitness encontrado: {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, 'b-', linewidth=2)  
plt.title('Convergência do PSO - Ackley')  
plt.xlabel('Iteração')  
plt.ylabel('Melhor fitness (escala log)')  
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 = ackley(X, Y)  
plt.contourf(X, Y, Z, levels=40, cmap='viridis', alpha=0.6)  
plt.colorbar(label='f(x,y)')  

# Trajetórias (plotar a cada 5 iterações para não poluir)  
for i in range(num_particulas):  
    traj = np.array([t[i] for t in trajetorias[::5]])  
    plt.plot(traj[:,0], traj[:,1], 'w-', linewidth=0.5, alpha=0.3)  
plt.scatter(gbest_pos[0], gbest_pos[1], color='red', s=120, edgecolor='white',  
            label='Melhor global')  
plt.scatter(0, 0, color='white', marker='*', s=200, label='Ótimo teórico')  
plt.title('Trajetórias das Partículas - PSO')  
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 Ackley (minimização)

def ackley(x, y):

term1 = -20 * np.exp(-0.2 * np.sqrt(0.5 * (x**2 + y**2)))

term2 = -np.exp(0.5 * (np.cos(2*np.pi*x) + np.cos(2*np.pi*y)))

return term1 + term2 + 20 + np.e

# Parâmetros PSO

num_particulas = 30

iteracoes = 200

w = 0.7

c1 = 1.5

c2 = 1.5

limites = [-5, 5]

dim = 2

# Inicialização

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

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

pbest_pos = posicoes.copy()

pbest_fit = np.array([ackley(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()]

trajetorias = [posicoes.copy()]

for it in range(iteracoes):

# Atualizar velocidade e posição

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]))

posicoes[i] += velocidades[i]

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

# Avaliar nova aptidão

fit_atual = np.array([ackley(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())

trajetorias.append(posicoes.copy())

print(f"Melhor fitness encontrado: {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, 'b-', linewidth=2)

plt.title('Convergência do PSO - Ackley')

plt.xlabel('Iteração')

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

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 = ackley(X, Y)

plt.contourf(X, Y, Z, levels=40, cmap='viridis', alpha=0.6)

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

# Trajetórias (plotar a cada 5 iterações para não poluir)

for i in range(num_particulas):

traj = np.array([t[i] for t in trajetorias[::5]])

plt.plot(traj[:,0], traj[:,1], 'w-', linewidth=0.5, alpha=0.3)

plt.scatter(gbest_pos[0], gbest_pos[1], color='red', s=120, edgecolor='white',

label='Melhor global')

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

plt.title('Trajetórias das Partículas - PSO')

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 inércia constante. A curva de convergência mostra uma rápida queda do erro nas primeiras iterações. O gráfico de trajetórias exibe como as partículas exploram o espaço e convergem. Mesmo com muitos mínimos locais, o enxame encontra o ótimo global. Para iniciantes, o PSO demonstra a inteligência coletiva de forma visual e intuitiva. A otimização por enxame de partículas é, portanto, uma técnica acessível e eficaz.

Ant Colony System (ACS)

16/07/202618/06/2026 Por antonino

O que é o Ant Colony System (ACS)?

O Ant Colony System (ACS) é uma evolução do Ant System original, proposta por Dorigo e Gambardella em 1997. Ele melhora a exploração e a convergência usando mecanismos mais sofisticados. Diferentemente do AS, o ACS introduz uma regra de transição pseudo-aleatória. Essa regra equilibra exploração e explotação de forma mais agressiva. Além disso, o ACS usa evaporação local durante a construção da rota. Cada formiga evapora feromônio das arestas que acabou de percorrer. Isso reduz a atratividade de caminhos já usados, promovendo diversidade. Após todas as formigas terminarem, apenas a melhor formiga deposita feromônio globalmente. Essa atualização global é mais seletiva, acelerando a convergência para boas soluções. Portanto, o ACS é mais rápido e eficiente que o AS para problemas grandes.

Características fundamentais do ACS

O ACS possui quatro características distintas que o diferenciam do AS. Primeiro, a regra de transição usa um parâmetro q₀ (entre 0 e 1). Com probabilidade q₀, a formiga escolhe a aresta mais promissora (exploração). Caso contrário, ela faz uma escolha probabilística como no AS (exploração). Segundo, a evaporação local é aplicada imediatamente após cada passo da formiga. Ela reduz o feromônio da aresta percorrida por um fator ξ (geralmente 0.1). Isso incentiva outras formigas a buscar caminhos alternativos. Terceiro, a atualização global é realizada apenas pela melhor formiga da iteração. Ela deposita feromônio nas arestas da rota ótima global ou da melhor iteração. Quarto, os parâmetros α e β são frequentemente fixados em 1 e 2, respectivamente. O ACS também usa uma lista tabu para evitar repetição de cidades. Essas características tornam o ACS mais adaptativo e com melhor desempenho.

Vantagens e aplicações típicas

O ACS é amplamente usado em problemas de roteamento e logística. Ele converge mais rapidamente que o AS, especialmente em TSP com 50+ cidades. Além disso, ele lida melhor com dinâmicas e restrições temporais. Sua regra pseudo-aleatória evita estagnação prematura em ótimos locais. Contudo, o ACS tem mais parâmetros para ajustar (q₀, ξ, β). Isso pode tornar a calibração mais trabalhosa para iniciantes. Ainda assim, o ACS é a base de muitas aplicações comerciais de otimização. Ele é considerado o estado da arte entre os algoritmos de colônia de formigas.

O ACS foi projetado especificamente para melhorar o desempenho do AS no TSP. Ele introduziu a ideia de “exploração guiada” pela regra pseudo-aleatória. Quando q ≤ q₀, a formiga escolhe a aresta com maior τ * η^β (gulosa). Quando q > q₀, ela usa a distribuição de probabilidades clássica. Isso permite um controle fino entre seguir o melhor caminho ou explorar novos. A evaporação local é aplicada com fator ξ, reduzindo τ em (1-ξ)*τ. Esse mecanismo simula o efeito de várias formigas usando a mesma aresta. A atualização global deposita feromônio apenas na melhor rota encontrada. O depósito é proporcional a 1/L_best, onde L_best é o comprimento da melhor rota. O ACS também permite o uso da melhor solução global ou da iteração corrente. Na prática, usar a melhor global acelera a convergência significativamente. O ACS supera o AS em qualidade de solução e tempo de execução. Ele é frequentemente comparado a algoritmos genéticos e simulated annealing. Assim, o ACS é uma ferramenta robusta e confiável para otimização combinatória.

Um exemplo clássico é o TSP com 30 cidades distribuídas aleatoriamente. O ACS encontra rotas muito próximas do ótimo em poucas iterações. A regra pseudo-aleatória evita que todas as formigas sigam o mesmo caminho. A evaporação local garante que arestas recentes percam atratividade temporária. Esse equilíbrio resulta em soluções de alta qualidade de forma consistente.

Enunciado do exemplo clássico

Implemente o Ant Colony System para o TSP com 25 cidades em [0,100]². Use 25 formigas, 150 iterações, α=1, β=2, ρ=0.1 (evaporação global), ξ=0.1 (evaporação local), q₀=0.9. A atualização global deve usar a melhor rota global encontrada até o momento. Armazene o custo da melhor rota a cada iteração e a própria rota. Plote a convergência e a rota final sobre as cidades com setas indicando a direção.

import numpy as np  
import matplotlib.pyplot as plt  

# Gerar cidades  
np.random.seed(13)  
n = 25  
coords = np.random.rand(n, 2) * 100  

# Distâncias  
dist = np.zeros((n, n))  
for i in range(n):  
    for j in range(n):  
        dist[i,j] = np.linalg.norm(coords[i] - coords[j])  

# Parâmetros ACS  
num_formigas = 25  
iteracoes = 150  
alpha = 1.0  
beta = 2.0  
rho = 0.1      # evaporação global  
xi = 0.1       # evaporação local  
q0 = 0.9  
tau0 = 1.0 / (n * np.mean(dist[dist > 0]))  

# Inicializar feromônio  
tau = np.full((n, n), tau0)  
np.fill_diagonal(tau, 0)  

# Históricos  
melhor_custo_hist = []  
melhor_rota_global = None  
melhor_custo_global = np.inf  

for it in range(iteracoes):  
    rotas = []  
    custos = []  

    for _ in range(num_formigas):  
        atual = np.random.randint(n)  
        rota = [atual]  
        nao_visitados = list(range(n))  
        nao_visitados.remove(atual)  

        while nao_visitados:  
            # Regra de transição pseudo-aleatória  
            if np.random.random() < q0:  
                # Escolha gulosa (exploração)  
                probs = []  
                for prox in nao_visitados:  
                    prob = (tau[atual, prox] ** alpha) * ((1.0 / dist[atual, prox]) ** beta)  
                    probs.append(prob)  
                prox = nao_visitados[np.argmax(probs)]  
            else:  
                # Escolha probabilística (exploração)  
                probs = []  
                for prox in nao_visitados:  
                    prob = (tau[atual, prox] ** alpha) * ((1.0 / dist[atual, prox]) ** beta)  
                    probs.append(prob)  
                probs = np.array(probs)  
                probs /= probs.sum()  
                prox = np.random.choice(nao_visitados, p=probs)  

            # Evaporação local (na aresta percorrida)  
            tau[atual, prox] = (1 - xi) * tau[atual, prox]  
            tau[prox, atual] = tau[atual, prox]  

            rota.append(prox)  
            nao_visitados.remove(prox)  
            atual = prox  

        # Fechar rota  
        custo = sum(dist[rota[i], rota[(i+1) % n]] for i in range(n))  
        rotas.append(rota)  
        custos.append(custo)  

        if custo < melhor_custo_global:  
            melhor_custo_global = custo  
            melhor_rota_global = rota.copy()  

    melhor_custo_hist.append(melhor_custo_global)  

    # Evaporação global  
    tau *= (1 - rho)  

    # Depósito global apenas pela melhor formiga (global)  
    deposito = 1.0 / melhor_custo_global  
    for i in range(n):  
        u = melhor_rota_global[i]  
        v = melhor_rota_global[(i+1) % n]  
        tau[u, v] += deposito  
        tau[v, u] += deposito  

print(f"Melhor custo final: {melhor_custo_global:.2f}")  
print("Melhor rota:", melhor_rota_global)  

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

plt.subplot(1, 2, 1)  
plt.plot(melhor_custo_hist, 'r-', linewidth=2)  
plt.title('Convergência do Ant Colony System')  
plt.xlabel('Iteração')  
plt.ylabel('Melhor comprimento')  
plt.grid(True)  

plt.subplot(1, 2, 2)  
plt.scatter(coords[:,0], coords[:,1], c='darkblue', s=80, zorder=5)  
rota_fechada = melhor_rota_global + [melhor_rota_global[0]]  
for i in range(len(rota_fechada)-1):  
    c1 = rota_fechada[i]  
    c2 = rota_fechada[i+1]  
    # Desenhar seta indicando direção  
    dx = coords[c2,0] - coords[c1,0]  
    dy = coords[c2,1] - coords[c1,1]  
    plt.arrow(coords[c1,0], coords[c1,1], dx*0.9, dy*0.9,  
              head_width=2.0, head_length=2.0, fc='green', ec='green',  
              length_includes_head=True, alpha=0.7)  
for i, (x, y) in enumerate(coords):  
    plt.annotate(str(i), (x+1.5, y+1.5), fontsize=9, fontweight='bold')  
plt.title('Melhor Rota - ACS com setas')  
plt.xlabel('X')  
plt.ylabel('Y')  
plt.grid(True)  
plt.tight_layout()  
plt.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

import numpy as np

import matplotlib.pyplot as plt

# Gerar cidades

np.random.seed(13)

n = 25

coords = np.random.rand(n, 2) * 100

# Distâncias

dist = np.zeros((n, n))

for i in range(n):

for j in range(n):

dist[i,j] = np.linalg.norm(coords[i] - coords[j])

# Parâmetros ACS

num_formigas = 25

iteracoes = 150

alpha = 1.0

beta = 2.0

rho = 0.1 # evaporação global

xi = 0.1 # evaporação local

q0 = 0.9

tau0 = 1.0 / (n * np.mean(dist[dist > 0]))

# Inicializar feromônio

tau = np.full((n, n), tau0)

np.fill_diagonal(tau, 0)

# Históricos

melhor_custo_hist = []

melhor_rota_global = None

melhor_custo_global = np.inf

for it in range(iteracoes):

rotas = []

custos = []

for _ in range(num_formigas):

atual = np.random.randint(n)

rota = [atual]

nao_visitados = list(range(n))

nao_visitados.remove(atual)

while nao_visitados:

# Regra de transição pseudo-aleatória

if np.random.random() < q0:

# Escolha gulosa (exploração)

probs = []

for prox in nao_visitados:

prob = (tau[atual, prox] ** alpha) * ((1.0 / dist[atual, prox]) ** beta)

probs.append(prob)

prox = nao_visitados[np.argmax(probs)]

else:

# Escolha probabilística (exploração)

probs = []

for prox in nao_visitados:

prob = (tau[atual, prox] ** alpha) * ((1.0 / dist[atual, prox]) ** beta)

probs.append(prob)

probs = np.array(probs)

probs /= probs.sum()

prox = np.random.choice(nao_visitados, p=probs)

# Evaporação local (na aresta percorrida)

tau[atual, prox] = (1 - xi) * tau[atual, prox]

tau[prox, atual] = tau[atual, prox]

rota.append(prox)

nao_visitados.remove(prox)

atual = prox

# Fechar rota

custo = sum(dist[rota[i], rota[(i+1) % n]] for i in range(n))

rotas.append(rota)

custos.append(custo)

if custo < melhor_custo_global:

melhor_custo_global = custo

melhor_rota_global = rota.copy()

melhor_custo_hist.append(melhor_custo_global)

# Evaporação global

tau *= (1 - rho)

# Depósito global apenas pela melhor formiga (global)

deposito = 1.0 / melhor_custo_global

for i in range(n):

u = melhor_rota_global[i]

v = melhor_rota_global[(i+1) % n]

tau[u, v] += deposito

tau[v, u] += deposito

print(f"Melhor custo final: {melhor_custo_global:.2f}")

print("Melhor rota:", melhor_rota_global)

# Gráficos

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

plt.subplot(1, 2, 1)

plt.plot(melhor_custo_hist, 'r-', linewidth=2)

plt.title('Convergência do Ant Colony System')

plt.xlabel('Iteração')

plt.ylabel('Melhor comprimento')

plt.grid(True)

plt.subplot(1, 2, 2)

plt.scatter(coords[:,0], coords[:,1], c='darkblue', s=80, zorder=5)

rota_fechada = melhor_rota_global + [melhor_rota_global[0]]

for i in range(len(rota_fechada)-1):

c1 = rota_fechada[i]

c2 = rota_fechada[i+1]

# Desenhar seta indicando direção

dx = coords[c2,0] - coords[c1,0]

dy = coords[c2,1] - coords[c1,1]

plt.arrow(coords[c1,0], coords[c1,1], dx*0.9, dy*0.9,

head_width=2.0, head_length=2.0, fc='green', ec='green',

length_includes_head=True, alpha=0.7)

for i, (x, y) in enumerate(coords):

plt.annotate(str(i), (x+1.5, y+1.5), fontsize=9, fontweight='bold')

plt.title('Melhor Rota - ACS com setas')

plt.xlabel('X')

plt.ylabel('Y')

plt.grid(True)

plt.tight_layout()

plt.show()

Este código implementa o ACS com todos os seus mecanismos diferenciadores. A curva de convergência mostra uma queda acentuada e estável. A rota final é desenhada com setas, indicando a direção do percurso. A evaporação local e a regra pseudo-aleatória produzem soluções de alta qualidade. Para iniciantes, o ACS demonstra como pequenas melhorias geram grandes ganhos. O Ant Colony System é, portanto, um algoritmo maduro e eficiente.