Per un essere umano una fotografia è una scena: una casa, il cielo, una collina. Per un computer è una tabella di numeri, uno per ogni pixel e per ogni canale di colore. Tutto ciò che chiamiamo “visione artificiale”, dal riconoscimento dei volti alla lettura delle targhe, parte da qui: trovare, in quella tabella, strutture che corrispondono a qualcosa di significativo.
L’operazione che ha reso possibile la visione artificiale moderna si chiama convoluzione, ed è il mattone fondamentale delle reti neurali convoluzionali (CNN). In quest’ultima parte della serie la implementiamo da zero in PHP puro, la applichiamo a un’immagine vera per trovarne i bordi e vediamo che cosa fa in più una rete neurale.
Un’immagine è una matrice
Per semplicità lavoriamo in scala di grigi: ogni pixel è un numero da 0 (nero) a 255 (bianco). Un bordo, per un computer, è un punto in cui questo numero cambia bruscamente passando da un pixel al vicino. In una regione uniforme, come un cielo o un muro, i valori vicini sono simili; sul confine tra il tetto e il cielo cambiano di colpo.
Che cos’è la convoluzione

La convoluzione usa una piccola matrice, detta kernel o filtro, tipicamente 3×3. Il kernel si sovrappone a un angolo dell’immagine; si moltiplicano tra loro i valori corrispondenti e si sommano i nove prodotti; il risultato è un pixel dell’immagine di uscita. Poi il kernel si sposta di una posizione e si ripete, fino a coprire tutta l’immagine. Il risultato si chiama mappa delle caratteristiche (feature map).
Tutto dipende dai numeri del kernel. Quello dello schema ha −1 nella riga in alto, 0 al centro e +1 in basso: in una zona uniforme i contributi si annullano e il risultato è zero; dove la parte inferiore è più chiara di quella superiore, il risultato è grande. È un rivelatore di bordi orizzontali.
Una precisazione per chi conosce la matematica: nelle reti neurali (e in questo articolo) il kernel viene applicato così com’è, senza essere ribaltato. A rigore è una correlazione incrociata, ma nell’apprendimento automatico si chiama convoluzione per convenzione.
L’implementazione in PHP
La funzione accetta un’immagine e un kernel come matrici di numeri, più due parametri che ritroveremo identici in ogni libreria di deep learning: il padding (quanti pixel di bordo aggiungere attorno all’immagine) e il passo o stride (di quanto spostare il kernel a ogni iterazione).
<?php
declare(strict_types=1);
/**
* Convoluzione 2D (come nelle reti neurali: il kernel non viene ribaltato).
*
* @param list<list<float>> $immagine matrice altezza × larghezza
* @param list<list<float>> $kernel matrice k × k (k dispari)
* @param int $padding pixel di bordo aggiunti attorno all'immagine (valore 0)
* @param int $passo spostamento del kernel a ogni iterazione (stride)
* @return list<list<float>>
*/
function convolvi(array $immagine, array $kernel, int $padding = 0, int $passo = 1): array
{
$h = count($immagine);
$w = count($immagine[0]);
$k = count($kernel);
if ($k % 2 === 0 || count($kernel[0]) !== $k) {
throw new InvalidArgumentException('Il kernel deve essere quadrato e di lato dispari.');
}
if ($padding > 0) {
$riga0 = array_fill(0, $w + 2 * $padding, 0.0);
$conBordo = array_fill(0, $padding, $riga0);
foreach ($immagine as $riga) {
$conBordo[] = [...array_fill(0, $padding, 0.0), ...$riga, ...array_fill(0, $padding, 0.0)];
}
array_push($conBordo, ...array_fill(0, $padding, $riga0));
$immagine = $conBordo;
$h += 2 * $padding;
$w += 2 * $padding;
}
$hOut = intdiv($h - $k, $passo) + 1;
$wOut = intdiv($w - $k, $passo) + 1;
$uscita = [];
for ($y = 0; $y < $hOut; $y++) {
$riga = [];
for ($x = 0; $x < $wOut; $x++) {
$somma = 0.0;
for ($i = 0; $i < $k; $i++) {
$rigaImg = $immagine[$y * $passo + $i];
$rigaKer = $kernel[$i];
for ($j = 0; $j < $k; $j++) {
$somma += $rigaImg[$x * $passo + $j] * $rigaKer[$j];
}
}
$riga[] = $somma;
}
$uscita[] = $riga;
}
return $uscita;
}
La dimensione dell’uscita segue una formula che vale ovunque: (dimensione + 2 × padding − kernel) / passo + 1. Con un’immagine 6×6, un kernel 3×3, nessun padding e passo 1 si ottiene una mappa 4×4.
Prove su una matrice
Costruiamo un’immagine 6×6 con la metà superiore scura (10) e quella inferiore chiara (90), e proviamo diversi kernel e parametri. Questo è l’output reale:
Kernel orizzontale
0 0 0 0
240 240 240 240
240 240 240 240
0 0 0 0
Kernel verticale
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
Kernel orizzontale con padding 1
20 30 30 30 30 20
0 0 0 0 0 0
160 240 240 240 240 160
160 240 240 240 240 160
0 0 0 0 0 0
-180 -270 -270 -270 -270 -180
Kernel orizzontale con passo 2 e padding 1
20 30 30
160 240 240
0 0 0
Il kernel orizzontale “accende” le due righe a cavallo del confine; quello verticale restituisce solo zeri, perché nell’immagine non c’è alcun cambiamento da sinistra a destra. Ogni kernel cerca un solo tipo di struttura.
Il padding mostra un effetto collaterale importante. Aggiungere una cornice di zeri conserva la dimensione dell’immagine (6×6 in ingresso, 6×6 in uscita), ma introduce bordi che non esistono: la prima e l’ultima riga contengono valori diversi da zero (20, 30, −180, −270) solo perché i pixel reali vengono confrontati con la cornice nera artificiale. Nelle applicazioni reali si usano spesso altri tipi di padding, ad esempio ripetendo i pixel del bordo. Il passo 2, infine, dimezza la risoluzione dell’uscita: è uno dei modi con cui le reti riducono progressivamente le dimensioni dei dati.
Su un’immagine vera: il filtro di Sobel
Passiamo a un’immagine reale. Usiamo una scena disegnata con la libreria GD di PHP (cielo sfumato, sole, una casa, due colline) e i kernel di Sobel, un classico della visione artificiale. Somigliano a quelli visti sopra, ma danno più peso alla riga o colonna centrale, cosa che li rende meno sensibili al rumore. Uno rileva le variazioni orizzontali, l’altro quelle verticali; combinandoli si ottiene l’intensità del bordo in ogni punto.

<?php
declare(strict_types=1);
require __DIR__ . '/Convoluzione.php';
/** Legge un'immagine con GD e la converte in una matrice di luminosità 0–255. */
function caricaInGrigi(string $file): array
{
$img = imagecreatefromstring(file_get_contents($file));
$w = imagesx($img);
$h = imagesy($img);
$grigi = [];
for ($y = 0; $y < $h; $y++) {
$riga = [];
for ($x = 0; $x < $w; $x++) {
$c = imagecolorat($img, $x, $y);
// luminanza percepita (pesi della raccomandazione ITU-R BT.601)
$riga[] = 0.299 * (($c >> 16) & 0xFF) + 0.587 * (($c >> 8) & 0xFF) + 0.114 * ($c & 0xFF);
}
$grigi[] = $riga;
}
return $grigi;
}
/** Salva una matrice come immagine in scala di grigi, riscalando i valori su 0–255. */
function salvaMappa(array $mappa, string $file, bool $inverti = false): void
{
$h = count($mappa);
$w = count($mappa[0]);
$max = max(array_map('max', $mappa)) ?: 1.0;
$img = imagecreatetruecolor($w, $h);
for ($y = 0; $y < $h; $y++) {
for ($x = 0; $x < $w; $x++) {
$v = (int) round(255 * $mappa[$y][$x] / $max);
$v = $inverti ? 255 - $v : $v;
imagesetpixel($img, $x, $y, ($v << 16) | ($v << 8) | $v);
}
}
imagepng($img, $file);
}
$sobelX = [[-1.0, 0.0, 1.0], [-2.0, 0.0, 2.0], [-1.0, 0.0, 1.0]];
$sobelY = [[-1.0, -2.0, -1.0], [0.0, 0.0, 0.0], [1.0, 2.0, 1.0]];
$grigi = caricaInGrigi('scena.png');
$gx = convolvi($grigi, $sobelX);
$gy = convolvi($grigi, $sobelY);
// intensità del bordo: lunghezza del vettore gradiente in ogni punto
$bordi = [];
foreach ($gx as $y => $riga) {
foreach ($riga as $x => $vx) {
$bordi[$y][$x] = sqrt($vx * $vx + $gy[$y][$x] * $gy[$y][$x]);
}
}
salvaMappa($bordi, 'bordi.png', inverti: true);
Questo è il risultato prodotto dal codice, con i colori invertiti per avere linee scure su fondo bianco:

I contorni della casa, del tetto, delle finestre, della porta, del sole e delle colline emergono con precisione. Il cielo, che pure cambia colore dall’alto in basso, non produce alcun bordo: la sfumatura è graduale, e da un pixel al successivo la differenza è minima. Due dettagli meritano attenzione:
- Le pareti laterali della casa sono appena visibili. Il colore crema dei muri e l’azzurro chiaro del cielo, una volta convertiti in scala di grigi, hanno una luminosità quasi identica. L’informazione c’era, nei colori, ed è andata persa nella conversione. È il motivo per cui le reti neurali lavorano sui tre canali di colore, con kernel tridimensionali.
- L’uscita misura 598×378 pixel, due in meno per lato rispetto all’originale 600×380: è la formula vista sopra, senza padding.
Applicando un solo kernel il ruolo di ciascun filtro diventa evidente. Con il solo Sobel lungo l’asse x restano soprattutto i bordi verticali (i lati delle finestre e della porta), mentre quelli orizzontali quasi scompaiono:

Prestazioni
Le due convoluzioni sull’immagine 600×380, insieme al calcolo dell’intensità, hanno richiesto circa 165 millisecondi in PHP 8.3 su una macchina con due vCPU. Per elaborazioni occasionali va benissimo. Per usi intensivi, la libreria GD offre già una convoluzione nativa 3×3, la funzione imageconvolution(), molto più veloce. Ha però un limite: lavora direttamente sui pixel, e i valori negativi prodotti da kernel come Sobel vengono tagliati a zero, a meno di aggiungere uno scostamento con il suo parametro offset. Per capire che cosa succede davvero, l’implementazione esplicita resta impareggiabile.
Dalla convoluzione alle reti convoluzionali
Fin qui abbiamo scelto noi i numeri del kernel, sapendo che cosa volevamo trovare. La differenza fondamentale di una rete neurale convoluzionale è che i numeri dei kernel vengono imparati dai dati durante l’addestramento. Nessuno dice alla rete di cercare bordi: lo scopre da sola, perché i bordi sono utili per riconoscere ciò che le si chiede di riconoscere.
Una CNN impila molti strati, ciascuno con decine o centinaia di kernel. I primi imparano strutture semplici (bordi, angoli, macchie di colore), quelli successivi le combinano in forme più complesse (un occhio, una ruota, una lettera), gli ultimi in concetti (un volto, un’automobile, una targa). Tra uno strato e l’altro si applicano due operazioni che possiamo scrivere in poche righe:
/** ReLU: azzera i valori negativi, introducendo la non linearità. */
function relu(array $mappa): array
{
return array_map(fn (array $riga): array => array_map(fn (float $v): float => max(0.0, $v), $riga), $mappa);
}
/** Max pooling: riduce la mappa tenendo il valore massimo di ogni blocco. */
function maxPooling(array $mappa, int $dimensione = 2): array
{
$uscita = [];
for ($y = 0; $y + $dimensione <= count($mappa); $y += $dimensione) {
$riga = [];
for ($x = 0; $x + $dimensione <= count($mappa[0]); $x += $dimensione) {
$massimo = -INF;
for ($i = 0; $i < $dimensione; $i++) {
for ($j = 0; $j < $dimensione; $j++) {
$massimo = max($massimo, $mappa[$y + $i][$x + $j]);
}
}
$riga[] = $massimo;
}
$uscita[] = $riga;
}
return $uscita;
}
La ReLU azzera i valori negativi: senza questa “non linearità”, impilare molti strati equivarrebbe a uno solo. Il max pooling riduce le dimensioni tenendo il valore più alto di ogni blocco: conserva l’informazione “qui c’è un bordo” perdendo la sua posizione esatta, cosa che rende la rete più robusta a piccoli spostamenti. Applicate in sequenza alla mappa 6×6 ottenuta con il padding, restituiscono una mappa 3×3 in cui il bordo è ancora chiaramente riconoscibile.
Addestrare una CNN in PHP puro è possibile in teoria ma poco pratico: servono milioni di convoluzioni ripetute per migliaia di iterazioni, ed è esattamente il tipo di calcolo per cui, come visto nella quinta parte, servono librerie native o la GPU. Usare in PHP una rete già addestrata, invece, è perfettamente fattibile con i runtime visti nella quarta parte.
Conclusione della serie
Con questo articolo si chiude il percorso su PHP e intelligenza artificiale. Ripercorrendolo, il filo conduttore è chiaro: PHP non deve diventare Python per partecipare a questa trasformazione. Può affiancare servizi specializzati, eseguire modelli pre-addestrati, implementare da sé gli algoritmi più semplici e, soprattutto, fare da regista: conoscere utenti, dati, permessi e regole, e decidere che cosa delegare e a chi.
- Riconoscere persone, luoghi e aziende nei testi (NER)
- Un assistente che risponde con i tuoi documenti (RAG con Neuron AI)
- Machine learning in PHP, senza Python
- Modelli neurali dentro PHP con TransformersPHP
- Dagli array alla GPU: l’ecosistema ML di PHP
- Bag of Words e TF-IDF: come le parole diventano numeri
- Agenti AI in PHP: dagli SDK alle piattaforme
- Convoluzione: i bordi di un’immagine in PHP puro (questo articolo)
In ogni parte abbiamo cercato di misurare invece di supporre: i risultati sbagliati sono stati utili quanto quelli giusti, e le soluzioni semplici hanno battuto spesso quelle più spettacolari. È forse la lezione più trasferibile di tutte.
Serie “PHP e intelligenza artificiale” – parte 8 di 8.
← Parte precedente: Agenti AI in PHP


