Ottimizzazione a sciame di particelle: inerzia, esperienza propria ed esperienza dello sciame

Boid e stormi, l’algoritmo PSO, le tre componenti della velocità, un’esecuzione sulla funzione di Rastrigin a confronto con una strategia evolutiva, il ruolo dell’inerzia, la stabilità di una particella, la topologia dello sciame e il teorema del «nessun pasto gratis».

13 minuti Matěj Žalmánek 2026-10-15

Serie Basi di IA Parte 30 di 52

1. Mappa dell’intelligenza artificiale: che cos’è ciascuna cosa e come si incastra tutto
2. Breve storia dell’intelligenza artificiale: da Turing ai modelli linguistici
3. Dati, modello, addestramento, inferenza: i concetti di base su un unico esempio
4. Come leggere la notazione matematica: simboli, indici, sommatorie e quantificatori
5. Insiemi e relazioni: i mattoncini con cui si costruiscono le definizioni nell’IA
6. Funzioni e applicazioni: perché ogni modello di IA è una funzione
7. Logica e dimostrazioni: le regole con cui si ragiona nell’IA
8. Grafi e alberi: la struttura su cui poggiano la ricerca e le reti neurali
9. Algebra lineare per l’apprendimento automatico: vettori, matrici e perché l’IA soprattutto moltiplica
10. Derivate, gradiente e regola della catena: come un modello capisce in quale direzione imparare
11. Discesa del gradiente: come impara un modello
12. Che cos’è la probabilità: dal lancio di un dado agli assiomi di Kolmogorov
13. Probabilità condizionata e teorema di Bayes: come cambiare una stima quando scopri qualcosa di nuovo
14. Variabile aleatoria e funzione di ripartizione: una sola funzione che dice tutto sulla distribuzione
15. Funzione di densità e funzione di massa: perché una variabile continua ha probabilità zero in un punto
16. Valore atteso, varianza e covarianza: dove si trova una distribuzione, quanto è larga e che cosa è legato a che cosa
17. Panoramica delle distribuzioni di probabilità: Bernoulli, binomiale, Poisson, uniforme, normale ed esponenziale
18. Legge dei grandi numeri e teorema del limite centrale: perché le medie si comportano in modo così prevedibile
19. Statistica e stima dei parametri: massima verosimiglianza, MAP e intervalli di confidenza
20. Teoria dell’informazione: entropia, entropia incrociata e divergenza KL — da dove vengono le funzioni di perdita
21. Ricerca nello spazio degli stati: BFS, DFS, UCS e A* con animazioni
22. Giochi e avversari: minimax, potatura alfa-beta e Monte Carlo tree search
23. Soddisfacimento di vincoli: backtracking, propagazione dei vincoli e AC-3 su un sudoku e una mappa delle regioni ceche
24. Logica e sistemi basati sulla conoscenza: concatenazione in avanti e all’indietro, risoluzione e sistemi esperti
25. Pianificazione: STRIPS, il mondo dei blocchi, euristiche dal rilassamento e pianificazione negli agenti IA
26. Ricerca locale e ricottura simulata: un commesso viaggiatore tra i capoluoghi di regione cechi
27. Algoritmi genetici: popolazione, incrocio, mutazione e selezione su uno zaino per l’escursione
28. Strategie evolutive e programmazione genetica: dalla regola di un quinto alla legge di Keplero
29. Ottimizzazione con colonie di formiche: come una traccia di feromone trova un percorso breve
30. Ottimizzazione a sciame di particelle: inerzia, esperienza propria ed esperienza dello sciame
31. Neuroevoluzione: evoluzione dei pesi e della forma delle reti neurali e l’algoritmo NEAT
32. Insiemi fuzzy e funzioni di appartenenza: come scrivere «un po’ caldo»
33. Logica fuzzy e probabilità: perché «un po’ caldo» non significa «probabilmente caldo»
34. Logica fuzzy: t-norme, implicazioni e regole SE–ALLORA
35. Controllo fuzzy: Mamdani e Sugeno, dal ventilatore al pendolo inverso su un carrello
36. Clustering fuzzy: l’algoritmo fuzzy c-means e i punti tra i cluster
37. Sistemi neuro-fuzzy (ANFIS): regole fuzzy che imparano dai dati
38. Catene di Markov: matrice di transizione, distribuzione stazionaria e PageRank
39. Modelli di Markov nascosti: l’algoritmo di Viterbi e il casinò disonesto
40. Reti bayesiane: perché l’erba è bagnata e che cosa significa per l’irrigatore
41. Filtro di Kalman: come stimare da misure imprecise dove si trova un’auto e a che velocità va
42. Tipi di apprendimento automatico: supervisionato, non supervisionato, semi-supervisionato e altri
43. Prompt, contesto e RAG: come dare a un modello le informazioni giuste
44. Autoencoder variazionali (VAE): immagini nuove da uno spazio latente continuo
45. Reti generative avversarie (GAN): il falsario contro il detective
46. Modelli di diffusione: come il rumore puro diventa un’immagine
47. Processi decisionali di Markov: stati, azioni, ricompense ed equazioni di Bellman
48. Q-learning e DQN: imparare il valore delle azioni, dalla tabella alla rete neurale
49. Policy gradient e PPO: imparare direttamente la politica
50. Come funziona un agente IA: un modello linguistico in un ciclo con strumenti
51. Programmare con agenti IA: incarico, test e controllo
52. Valutazione e sicurezza dei sistemi di IA: come misurare e come sorvegliare

Programma completo della serie 52 di 83 argomenti pubblicati

Uno stormo di storni sopra la città al tramonto si muove come un unico essere vivente — eppure non ha un capo. Ogni uccello osserva solo pochi vicini più prossimi. Nel 1995 lo psicologo sociale James Kennedy e l’ingegnere elettrico Russell Eberhart si sono posti una domanda: e se gli uccelli, oltre alla posizione dei vicini, si passassero anche l’informazione su dove hanno trovato più cibo? Dalla loro simulazione è nato uno degli algoritmi di ottimizzazione più semplici e più usati in assoluto — l’ottimizzazione a sciame di particelle (particle swarm optimization, PSO).

Riprende le parti Strategie evolutive e programmazione genetica e Ottimizzazione con colonie di formiche. Lanceremo lo sciame sulla stessa funzione di Rastrigin della strategia evolutiva, con la stessa partenza e lo stesso budget.

1. Stormi in natura e nel computer

Già nel 1987 Craig Reynolds mostrò che per un movimento di stormo credibile bastano tre regole locali. I suoi «boid» evitano le collisioni con i vicini più prossimi, allineano con loro la direzione di volo e restano vicini al centro del gruppo. Nessuno guida l’insieme; la forma dello stormo emerge dalle regole locali. Kennedy ed Eberhart aggiunsero una quarta cosa — la memoria dei posti buoni — e l’animazione divenne un ottimizzatore.

Definizione — le tre regole dei boid (semplificate)

Reynolds descrisse le regole a parole; oggi di solito si scrivono così. Il boid i ha una posizione x_i, una velocità v_i e un intorno S_i — i boid più vicini di un raggio dato. Alla propria velocità aggiunge una somma pesata di tre vettori:

• separazione −∑_{j ∈ Si} (x_j − x_i) / ‖x_j − x_i‖² — repulsione, tanto più forte quanto più il vicino è vicino;
• allineamento v̄_i − v_i, dove v̄_i è la velocità media dei vicini;
• coesione x̄_i − x_i, dove x̄_i è la posizione media dei vicini.

Ogni boid usa quindi solo informazioni del proprio intorno. Le equazioni della PSO qui sotto hanno la stessa forma «velocità ← velocità + attrazioni verso obiettivi», solo che gli obiettivi non sono i vicini, ma i posti migliori trovati.

2. L’algoritmo

Definizione — ottimizzazione a sciame di particelle

Minimizziamo f : ℝⁿ → ℝ. Lo sciame è formato da N particelle; la particella i ha una posizione x_i, una velocità v_i e la sua migliore posizione finora p_i. Lo sciame conosce la migliore posizione di tutte, g. A ogni iterazione, per ogni particella:

v_i ← w · v_i + c₁ r₁ (p_i − x_i) + c₂ r₂ (g − x_i),

x_i ← x_i + v_i,

dove r₁, r₂ sono numeri casuali in [0, 1) estratti separatamente per ogni coordinata. Se f(x_i) < f(p_i), si aggiorna p_i ed eventualmente anche g.

Valori consueti (Clerc e Kennedy, 2002): w = 0,7298, c₁ = c₂ = 1,49618.

v_i ← w · v_i + c₁ r₁ (p_i − x_i) + c₂ r₂ (g − x_i)

v_i a sinistra

la nuova velocità — di quanto si sposta la particella in questo passo (x_i ← x_i + v_i); lo sciame non controlla la posizione direttamente ma attraverso la velocità, e per questo il moto è fluido

w · v_i

inerzia — una parte della vecchia velocità rimane; w < 1 al tempo stesso la smorza, così che il moto col tempo si calmi

c₁ r₁, c₂ r₂

forza dell’attrazione — c fissa la forza media, l’r casuale in [0, 1) la accorcia ogni volta in modo diverso, così la particella non atterra esattamente sull’obiettivo e lungo la strada assaggia anche i posti intorno

p_i − x_i

il vettore dalla particella al suo posto migliore — più è lontano, più forte la tira indietro (come una molla)

g − x_i

il vettore verso il posto migliore dello sciame — l’unico canale attraverso cui l’esperienza altrui raggiunge la particella

Definizione — limitazione della velocità

Dopo il calcolo ogni coordinata della velocità viene tagliata all’intervallo [−v_max, v_max]: v_id ← min(v_max, max(−v_max, v_id)). La nostra implementazione usa v_max = 5,12, cioè metà della larghezza del quadrato di ricerca [−5,12; 5,12]² — una particella non attraversa in un solo passo più di mezza mappa.

Esempio — un passo di una particella

Una particella si trova in x = (4,2; −3,8) con velocità v = (0,5; 0,4). Il suo posto migliore è p = (4,0; −3,1), il posto migliore dello sciame g = (1,1; −2,0). Sono usciti i numeri casuali r₁ = (0,6; 0,3) e r₂ = (0,5; 0,8). Prima coordinata:

• inerzia 0,7298 · 0,5 = 0,365,
• cognitiva 1,49618 · 0,6 · (4,0 − 4,2) = −0,180,
• sociale 1,49618 · 0,5 · (1,1 − 4,2) = −2,319,
• nuova velocità 0,365 − 0,180 − 2,319 = −2,134, nuova posizione 4,2 − 2,134 = 2,066.

La seconda coordinata allo stesso modo: 0,292 + 0,314 + 2,154 = 2,761, nuova posizione −3,8 + 2,761 = −1,039. Entrambe le componenti della velocità sono sotto v_max, la limitazione non interviene. Il valore della funzione (quella di Rastrigin, vedi sotto) è sceso da 45,90 a 6,51. La componente sociale qui è la più grande, perché g è lontano; quella cognitiva è piccola, perché p si trova a due passi dalla particella.

import random

def pso(f, n, castic=40, iteraci=200, w=0.7298, c1=1.49618, c2=1.49618):
    x = [[random.uniform(-5, 5) for _ in range(n)] for _ in range(castic)]
    v = [[0.0] * n for _ in range(castic)]
    p = [xi[:] for xi in x]                              # posto migliore di ogni particella
    g = min(p, key=f)[:]                                 # posto migliore dello sciame
    for _ in range(iteraci):
        for i in range(castic):
            for d in range(n):
                v[i][d] = (w * v[i][d]
                           + c1 * random.random() * (p[i][d] - x[i][d])
                           + c2 * random.random() * (g[d] - x[i][d]))
                x[i][d] += v[i][d]
            if f(x[i]) < f(p[i]):
                p[i] = x[i][:]
                if f(p[i]) < f(g):
                    g = p[i][:]
    return g

Il costo dell’algoritmo si misura in numero di valutazioni di f — nei problemi reali ognuna è costosa (una simulazione, l’addestramento di un modello). Ogni particella viene valutata alla partenza e poi una volta per iterazione, in totale N + N · T = 40 + 40 · 200 = 8 040 per N = 40 particelle e T = 200 iterazioni. (Lo pseudocodice qui sopra chiama f più volte per chiarezza; l’implementazione reale si ricorda i valori f(p_i).)

3. Tre forze

• Inerzia w · v — la particella non vuole cambiare direzione bruscamente. Grazie a lei lo sciame sorvola le buche poco profonde invece di cadere in ciascuna.
• Componente cognitiva c₁ r₁ (p − x) — esperienza propria: «lì mi sono trovata bene». Mantiene la diversità, perché ogni particella ricorda qualcosa di diverso.
• Componente sociale c₂ r₂ (g − x) — esperienza dello sciame: «lì c’è il meglio che qualcuno abbia trovato». Tiene unito lo sciame.

A differenza degli algoritmi genetici, qui nessuno muore e niente si incrocia. L’informazione si diffonde solo perché le particelle vedono il successo altrui. E a differenza delle strategie evolutive, la particella ha una velocità — uno slancio che la porta avanti anche quando le cose non vanno bene.

4. Lo sciame sulla funzione di Rastrigin

La funzione di Rastrigin della parte precedente: una ciotola con una griglia regolare di buche, il minimo globale nell’origine. 40 particelle partono intorno al punto (4,2; −3,8), dove f ≈ 45,9 — là dove partiva la strategia evolutiva:

Definizione — la funzione di Rastrigin

Per x = (x₁, …, x_n) ∈ [−5,12; 5,12]ⁿ si ha

f(x) = 10n + ∑_d=1ⁿ (x_d² − 10 cos(2πx_d)).

Il minimo globale è f(0, …, 0) = 0; i minimi locali si trovano vicino a ogni punto a coordinate intere, e nel quadrato ce ne sono, in due dimensioni, 11 · 11 = 121.

f(x) = 10n + ∑_d (x_d² − 10 cos(2πx_d))

f(x)

il valore che lo sciame minimizza — un paesaggio di prova di cui conosciamo il minimo, così sappiamo riconoscere il successo

10n

uno spostamento — nell’origine il coseno vale 1 e ogni coordinata dà −10; questo termine compensa, così che il minimo valga esattamente 0

∑_d

una somma sulle coordinate — ognuna contribuisce in modo indipendente, così il numero di buche cresce esponenzialmente con la dimensione (11ⁿ)

x_d²

la ciotola — la pendenza complessiva verso l’origine; senza di essa tutte le buche sarebbero ugualmente profonde e non ci sarebbe alcun minimo globale

− 10 cos(2πx_d)

un’ondulazione di periodo 1 — scava una buca a ogni numero intero e, con ampiezza 10, le rende abbastanza profonde perché un metodo locale vi resti bloccato

Esempio — il valore nel punto di partenza

Per x = (4,2; −3,8): cos(2π · 4,2) = cos(8,4π) = cos(0,4π) ≈ 0,309 e cos(2π · (−3,8)) = cos(7,6π) = cos(1,6π) ≈ 0,309. Quindi

f = 20 + (17,64 − 3,090) + (14,44 − 3,090) = 20 + 14,550 + 11,350 ≈ 45,9.

La partenza si trova sul pendio della buca in (4; −4), dove f = 20 + (16 − 10) + (16 − 10) = 32; il fondo vero è un pelo più vicino all’origine, con un valore di circa 31,84. Il valore 31,9 dopo la prima iterazione (sotto) significa quindi che lo sciame è scivolato quasi sul fondo della buca di partenza. Più vicino al minimo arriverà solo attraversando le creste fra le buche.

Dopo la prima iterazione il posto migliore dello sciame ha valore 31,9. Poi succede una cosa che la strategia evolutiva non faceva: lo sciame si sparpaglia. La dispersione delle particelle sale da 0,7 a 1,3 alla decima iterazione — le particelle oltrepassano i loro posti migliori e strada facendo scoprono nuove buche. Alla 25ª iterazione il posto migliore ha valore 1,06, una buca accanto al minimo, e alla 50ª iterazione lo sciame trova il minimo globale. Poi si stringe intorno a esso.

Definizione — dispersione dello sciame ed esecuzione riuscita

La dispersione dello sciame è la radice quadrata della media del quadrato della distanza delle particelle dal loro baricentro x̄ = (1/N) ∑_i x_i:

σ = √( (1/N) ∑_i=1^N ‖x_i − x̄‖² ).

Un’esecuzione ha trovato il minimo globale se alla fine f(g) < 0,01. I minimi locali più vicini hanno valori intorno a 1 (per questo 1,06 alla 25ª iterazione significa «la buca accanto»), così questa soglia li distingue nettamente.

σ = √( (1/N) ∑_i ‖x_i − x̄‖² )

σ

un solo numero per «quanto è sparpagliato lo sciame» — in unità delle coordinate, così lo si può confrontare con la distanza fra le buche (1)

(1/N) ∑_i

una media sulle particelle — il risultato non dipende dalla dimensione dello sciame

‖x_i − x̄‖²

il quadrato della distanza dal baricentro — misuriamo dal centro dello sciame, non dal minimo, perché ci interessa la forma dello sciame, non dove si trova; il quadrato pesa di più gli esploratori lontani e la radice riporta poi alle unità originali

Traccia della stessa esecuzione, iterazione per iterazione:

Per quattro iterazioni il miglior valore non si muove e intanto lo sciame si stringe dentro la buca di partenza (alla terza iterazione σ è solo 0,53); poi l’inerzia e le attrazioni verso g lo allargano di nuovo e il miglior valore scende di buca in buca — 31,9, 25,6, 5,9, 1,06. Il minimo viene trovato alla 50ª iterazione, ma σ è allora ancora 0,96: lo sciame si raccoglie intorno al minimo solo dopo.

Su cento esecuzioni con semi diversi lo sciame ha trovato il minimo globale in 97 — con un budget di 8 040 valutazioni. La strategia evolutiva (15, 100) con 8 000 valutazioni dello stesso problema ha avuto successo in 32 casi. Quando lo sciame parte distribuito su tutto il quadrato invece che da un angolo, riesce in tutte e cento.

5. Inerzia ed equilibrio delle forze

Che cosa succede se cambiamo solo l’inerzia? Il grafico mostra quanto sono lontane fra loro le particelle (l’asse verticale è logaritmico):

Con w = 0,4 lo sciame collassa in un solo punto prima di riuscire a guardarsi intorno — resta bloccato in una buca di valore 24,9. Con w = 0,9 resta sparpagliato per tutto il tempo: il minimo lo trova, ma non si stringe mai intorno a esso e non lo rifinisce. Su cento esecuzioni per ogni impostazione:

Senza la componente sociale lo sciame è solo un gruppo di quaranta scalatori solitari che non sanno nulla l’uno dell’altro — nessuno esce dall’angolo. Senza quella cognitiva tutti inseguono un unico capo e metà delle volte restano bloccati con lui. Solo le due componenti insieme danno l’equilibrio fra esplorazione e sfruttamento che abbiamo già incontrato con la ricottura.

6. Perché lo sciame non impazzisce

La velocità continua a sommarsi. Perché non cresce all’infinito? La risposta la dà l’analisi di una sola particella, se per un momento dimentichiamo il caso.

Teorema — stabilità di una particella

Consideriamo una particella unidimensionale con p e g fissi e, al posto di c₁r₁, c₂r₂, numeri fissi di somma φ. La posizione segue allora la ricorrenza lineare

x_t+1 = (1 + w − φ) x_t − w x_t−1 + cost.

e la particella converge (a una media pesata di p e g) se e solo se |w| < 1 e 0 < φ < 2 (1 + w).

Dimostrazione — da dove vengono la ricorrenza e le condizioni

Senza caso, il passo unidimensionale è v_t+1 = wv_t + φ₁(p − x_t) + φ₂(g − x_t) e x_t+1 = x_t + v_t+1. Poniamo φ = φ₁ + φ₂ e P = (φ₁p + φ₂g)/φ (la media pesata dei due posti migliori). Allora φ₁(p − x) + φ₂(g − x) = φ(P − x) e, sostituendo v_t = x_t − x_t−1:

x_t+1 = (1 + w − φ) x_t − w x_t−1 + φP.

Lo scarto e_t = x_t − P soddisfa la stessa ricorrenza senza la costante, quindi e_t = aλ₁^t + bλ₂^t, dove λ_1,2 sono le radici dell’equazione caratteristica λ² − (1 + w − φ)λ + w = 0. La particella si assesta in P se e solo se |λ₁|, |λ₂| < 1. Per un’equazione di secondo grado λ² + aλ + b = 0 ciò avviene esattamente quando |b| < 1 e 1 ± a + b > 0 (criterio di Jury). Qui b = w, a = −(1 + w − φ):

• |w| < 1,
• 1 − (1 + w − φ) + w = φ > 0,
• 1 + (1 + w − φ) + w = 2(1 + w) − φ > 0. ∎

x_t+1 = (1 + w − φ) x_t − w x_t−1 + φP

x_t+1

la posizione successiva — dipende dalle due precedenti, perché la velocità è la differenza di due posizioni; per questo la particella si comporta come un corpo che oscilla, non come una palla che rotola giù per un pendio

(1 + w − φ) x_t

la posizione attuale spinta avanti dall’inerzia (+w) e richiamata dall’attrazione (−φ) — il duello fra «continuare a volare» e «tornare»

− w x_t−1

la memoria del passo precedente — questo termine porta lo slancio; il suo coefficiente w è il prodotto delle radici, e per questo lo smorzamento lo determina proprio l’inerzia

φP

l’àncora — l’attrazione della media pesata di p e g; la particella oscilla intorno a essa e vi si assesta

Quanto in fretta si assesta? Per i φ consueti entrambe le radici risultano complesse (la particella oscilla) e hanno lo stesso modulo √w, perché il loro prodotto è w. L’ampiezza dello scarto viene quindi moltiplicata a ogni iterazione per √w e si dimezza in ln 2 / (−ln √w) iterazioni. Con il φ medio = (c₁ + c₂)/2 = 1,49618 (l’r casuale ha media ½):

Ciò corrisponde esattamente al grafico della dispersione qui sopra: con w = 0,4 lo sciame si raccoglie in poche iterazioni, con w = 0,9 le oscillazioni si spengono nell’arco di decine di iterazioni. È una semplificazione — gli r reali vengono estratti a ogni passo e p, g cambiano —, ma l’ordine di grandezza torna. E attenzione: con w = 0,4 il limite 2(1 + w) = 2,8 è minore del massimo φ = c₁ + c₂ ≈ 2,99 possibile, quindi un’attrazione casuale eccezionalmente forte fa oscillare la particella per un passo (smorzamento 1,280 > 1).

7. Chi sente chi: la topologia

Definizione — topologia dello sciame

La topologia è un grafo che determina di chi una particella vede i posti migliori. Nella topologia globale (gbest) ognuna vede tutte le altre e g è comune. Nella topologia ad anello (lbest) le particelle stanno in un anello e la particella i vede solo i − 1, i e i + 1; al posto di g usa il posto migliore del proprio intorno.

Formalmente ogni particella i ha un intorno S(i) e nella regola della velocità usa, al posto del g comune, g_i = p_k, dove k = arg min_{j ∈ S(i)} f(p_j). La topologia globale ha S(i) = {1, …, N}, quella ad anello S(i) = {i − 1, i, i + 1} (indici modulo N). Quante iterazioni ci vogliono perché la notizia di un nuovo ritrovamento arrivi a tutti? Nella topologia globale, una. Nell’anello avanza per iterazione al massimo di un vicino per lato, e la particella più lontana in un anello di 40 particelle è a 20 posti di distanza — la notizia la raggiunge al più presto dopo 20 iterazioni. Per tutto quel tempo le parti lontane dello sciame possono esplorare per conto proprio.

Sul nostro problema bidimensionale l’anello ha trovato il minimo in tutte le 100 esecuzioni, la topologia globale in 97. La differenza è più netta in dieci dimensioni, dove le buche sono astronomicamente tante: dopo 2 000 iterazioni la topologia globale è finita in media sul valore 5,84, quella ad anello su 4,57. Il minimo globale non l’ha trovato nessuna delle due — la funzione di Rastrigin in dieci dimensioni è davvero difficile per 40 particelle.

8. Attenzione alle metafore

Teorema — nessun pasto gratis (Wolpert e Macready, 1997)

In media su tutte le possibili funzioni obiettivo su un insieme finito, tutti gli algoritmi che non valutano due volte lo stesso punto hanno la stessa prestazione attesa.

Più precisamente: siano X e Y insiemi finiti, f : X → Y una funzione obiettivo e d_m^y la successione dei valori che l’algoritmo vede durante m valutazioni distinte. Allora per due algoritmi qualsiasi a₁, a₂

∑_f P(d_m^y | f, m, a₁) = ∑_f P(d_m^y | f, m, a₂),

dove si somma su tutte le |Y|^|X| funzioni. Ogni misura di prestazione che dipende solo dai valori visti (per esempio il migliore trovato) ha quindi la stessa media su tutte le funzioni.

Dopo il successo delle formiche e dello sciame si è aperta una valanga di algoritmi «ispirati alla natura»: lucciole, cuculi, pipistrelli, lupi grigi, l’armonia di un gruppo jazz. Kenneth Sörensen nel 2015 ha fatto notare che molti di essi sono vecchie idee in un costume nuovo — la metafora ha sostituito la descrizione matematica e ha reso più difficile il confronto. La domanda giusta davanti a ogni nuovo algoritmo non è quindi «a che cosa si ispira», ma «che cosa fa di diverso da quelli noti, e dove lo si vede».

9. Gli sciami nella pratica

• Regolazione dei parametri. La PSO è apprezzata dove i parametri sono pochi, il gradiente non è noto e una valutazione è una simulazione: taratura di regolatori, forma di antenne, gestione di reti elettriche o iperparametri di modelli di apprendimento automatico.
• Robot in sciame. A Harvard, nel 2014, 1 024 piccoli robot Kilobot hanno composto forme assegnate seguendo regole locali — senza controllo centrale, solo comunicando con i vicini.
• E i droni degli spettacoli pirotecnici? Gli spettacoli di luci con migliaia di droni non sono intelligenza di sciame: ogni drone segue una traiettoria calcolata in anticipo da un piano centrale. Uno sciame in senso proprio decide da sé, in base ai vicini.

10. Riepilogo

• Una particella della PSO cambia velocità in base all’inerzia, al proprio posto migliore e al posto migliore dello sciame.
• Sulla funzione di Rastrigin lo sciame ha trovato il minimo in 97 esecuzioni su 100 — la strategia evolutiva con la stessa partenza e lo stesso budget in 32.
• L’inerzia controlla quanto a lungo lo sciame esplora: se è piccola lo fa collassare prima del tempo, se è grande non gli lascia rifinire il risultato. Senza la componente sociale, come senza quella cognitiva, lo sciame fallisce.
• Una particella è come una molla smorzata; per |w| < 1 e 0 < φ < 2(1 + w) si assesta.
• La topologia ad anello diffonde l’informazione più lentamente e sui problemi difficili tende a essere più robusta; e secondo il teorema del «nessun pasto gratis» non esiste un ottimizzatore migliore per tutto.

Vuoi metterci le mani? Fai scrivere a un agente IA una PSO con una visualizzazione dello sciame, dagli un paesaggio tuo — per esempio una funzione con due valli lontane — e guarda se lo sciame si divide.

La vedi diversamente? Scrivi a support@coden-app.com.