Vai al contenuto

PHP e intelligenza artificiale – Parte 5: dagli array alla GPU, l’ecosistema ML di PHP

Nelle parti precedenti abbiamo usato l’intelligenza artificiale in PHP in modi molto diversi: addestrando un modello in PHP puro, eseguendo reti neurali tramite una libreria nativa, orchestrando modelli esterni. Viene spontaneo chiedersi quale sia la strada “giusta”, e soprattutto dove stia il limite di PHP.

Per rispondere serve capire una cosa sola: tutto il machine learning, alla fine, è calcolo su grandi quantità di numeri. Vettori, matrici, tensori. In questa parte misuriamo quanto costa questo calcolo in PHP, perché costa così tanto, e come l’ecosistema si è organizzato per aggirare il problema. Con un benchmark che chiunque può rifare.

Tutto è moltiplicazione di matrici

Un livello di una rete neurale riceve un vettore di numeri, lo moltiplica per una matrice di pesi, aggiunge un vettore e applica una funzione. Un modello di embedding come quello usato nella parte precedente ripete questa operazione decine di volte per ogni frase. Addestrare un modello significa ripeterla milioni di volte. Per questo la velocità con cui un ambiente esegue il prodotto tra matrici è un buon indicatore della sua idoneità al machine learning.

L’esperimento

Moltiplichiamo due matrici quadrate di numeri casuali in quattro modi:

  1. con gli array di PHP e tre cicli annidati;
  2. con gli stessi array, attivando il compilatore JIT di PHP;
  3. delegando il calcolo alla funzione cblas_dgemm della libreria BLAS di riferimento, richiamata tramite FFI;
  4. delegandolo a OpenBLAS, un’implementazione di BLAS ottimizzata per i processori moderni, anch’essa via FFI.

BLAS (Basic Linear Algebra Subprograms) è l’interfaccia standard, nata negli anni Settanta, per le operazioni di algebra lineare. Quasi tutte le librerie scientifiche, NumPy compresa, finiscono per chiamarla. La versione PHP pura usa l’ordine dei cicli più favorevole alla cache del processore:

function moltiplicaPhp(array $a, array $b, int $n): array
{
    $c = array_fill(0, $n, array_fill(0, $n, 0.0));
    for ($i = 0; $i < $n; $i++) {
        $ai = $a[$i];
        $ci = $c[$i];
        for ($k = 0; $k < $n; $k++) {
            $aik = $ai[$k];
            $bk = $b[$k];
            for ($j = 0; $j < $n; $j++) {
                $ci[$j] += $aik * $bk[$j];
            }
        }
        $c[$i] = $ci;
    }

    return $c;
}

La versione nativa dichiara a FFI la firma della funzione C, copia i dati in buffer nativi, chiama BLAS e ricopia il risultato in un array PHP:

function moltiplicaBlas(array $a, array $b, int $n, string $libreria): array
{
    $ffi = FFI::cdef(
        'void cblas_dgemm(int Order, int TransA, int TransB, int M, int N, int K,
                          double alpha, const double *A, int lda, const double *B, int ldb,
                          double beta, double *C, int ldc);',
        $libreria,
    );

    // copia dagli array PHP alla memoria nativa (row-major)
    $A = FFI::new("double[$n*$n]");
    $B = FFI::new("double[$n*$n]");
    $C = FFI::new("double[$n*$n]");
    for ($i = 0, $p = 0; $i < $n; $i++) {
        for ($j = 0; $j < $n; $j++, $p++) {
            $A[$p] = $a[$i][$j];
            $B[$p] = $b[$i][$j];
        }
    }

    // 101 = CblasRowMajor, 111 = CblasNoTrans
    $ffi->cblas_dgemm(101, 111, 111, $n, $n, $n, 1.0, $A, $n, $B, $n, 0.0, $C, $n);

    // copia del risultato in un array PHP
    $c = [];
    for ($i = 0, $p = 0; $i < $n; $i++) {
        for ($j = 0; $j < $n; $j++, $p++) {
            $c[$i][$j] = $C[$p];
        }
    }

    return $c;
}

In poche righe abbiamo fatto esattamente ciò che fanno, in modo più curato, le librerie dell’ecosistema: usare PHP per preparare i dati e una libreria nativa per calcolare. Il percorso della libreria (ad esempio /usr/lib/x86_64-linux-gnu/openblas-pthread/libblas.so.3 su Ubuntu) dipende dal sistema.

I risultati

Grafico a barre su scala logaritmica: array PHP 1.877 ms, array PHP con JIT 415,6 ms, BLAS di riferimento via FFI 114,4 ms, OpenBLAS via FFI 30,9 ms totali di cui 5,3 ms di solo calcolo

Questi sono i tempi misurati con PHP 8.3 su una macchina con due vCPU, per diverse dimensioni delle matrici (tutte le versioni producono lo stesso risultato numerico):

Dimensione Array PHP Array PHP + JIT BLAS di riferimento OpenBLAS (totale) OpenBLAS (solo calcolo)
128 × 128 30 ms 7 ms 4 ms 5 ms 0,2 ms
256 × 256 230 ms 78 ms 17 ms 9 ms 1,1 ms
512 × 512 1.877 ms 416 ms 114 ms 31 ms 5,3 ms
1024 × 1024 — — 720 ms 129 ms 33 ms

Tre osservazioni.

Primo: gli array di PHP sono lenti per questo lavoro, e il motivo è strutturale. A 512×512, OpenBLAS calcola il prodotto circa 350 volte più in fretta del codice PHP. Non è colpa di chi ha scritto il ciclo: ogni operazione passa dall’interprete, ogni numero è un valore generico che porta con sé il proprio tipo, e la memoria non è disposta in modo contiguo. Una misura lo rende evidente: una matrice 512×512 in un array PHP occupa circa 6 MB, circa 24 byte per numero, contro i 2 MB (8 byte per numero) di un buffer nativo di double.

Secondo: il JIT aiuta parecchio, ma non cambia categoria. Attivando il compilatore JIT (opcache.jit=tracing) il codice PHP diventa da tre a cinque volte più veloce. È un miglioramento notevole, che rende il PHP puro adatto a calcoli di dimensione moderata, ma resta lontano dalle librerie ottimizzate, che sfruttano istruzioni vettoriali del processore, più core e un uso accurato della cache.

Terzo, il più importante: spostare i dati costa più che calcolare. Con OpenBLAS a 512×512, il calcolo vero e proprio richiede 5,3 millisecondi, mentre l’operazione completa ne richiede 31. Quasi tutto il tempo se ne va a copiare i numeri dagli array PHP alla memoria nativa e ritorno. È la stessa lezione che vale, moltiplicata, per la GPU: la scheda grafica calcola rapidissimamente, ma i dati vanno prima trasferiti nella sua memoria. Il segreto delle prestazioni non è soltanto una libreria veloce: è tenere i dati nel formato nativo il più a lungo possibile, invece di convertirli avanti e indietro a ogni operazione.

Come si è organizzato l’ecosistema

Cinque livelli dal basso verso l’alto: array di PHP, librerie in PHP puro come Rubix ML, estensioni in C come Tensor e NumPower, runtime nativi via FFI come ONNX Runtime e BLAS, PHP come orchestratore di servizi di inferenza

Le librerie per il machine learning in PHP si possono leggere come risposte diverse ai tre problemi emersi dal benchmark: l’interprete, la memoria e lo spostamento dei dati.

1. Array di PHP

Flessibili, onnipresenti, adatti a prototipi, a dataset piccoli e agli algoritmi didattici. Ne vedremo il valore nella prossima parte, dove implementeremo da zero un algoritmo classico di elaborazione del testo.

2. Librerie in PHP puro

Rubix ML, usata nella terza parte della serie, implementa decine di algoritmi completamente in PHP. Il vantaggio è la portabilità assoluta: funziona ovunque giri PHP, senza estensioni né librerie di sistema. Per i dati tabellari di dimensione media e per gli algoritmi classici (alberi, foreste, k-NN, regressioni) le prestazioni sono più che sufficienti.

3. Estensioni in C

Il passo successivo è portare le strutture dati fuori dagli array di PHP. Tensor, dello stesso ecosistema di Rubix ML, offre vettori e matrici con un’implementazione in PHP e un’estensione opzionale in C che ne accelera le operazioni. NumPower si ispira dichiaratamente a NumPy: un’estensione che gestisce array multidimensionali nativi, usa le istruzioni vettoriali dei processori moderni e, se compilata con il supporto CUDA, può eseguire le operazioni su una GPU NVIDIA. Nato come progetto indipendente, è proseguito come fork all’interno dell’organizzazione Rubix ML. Il suo modello di utilizzo rende esplicito il punto del benchmark: i dati vanno copiati nella memoria della GPU prima del calcolo, ed è lì che conviene tenerli.

Il prezzo delle estensioni è l’installazione: vanno compilate e abilitate sul server, cosa non sempre possibile su hosting condivisi o in ambienti gestiti.

4. Runtime nativi via FFI

FFI permette di usare librerie native già esistenti senza scrivere un’estensione. È la strada di TransformersPHP, che delega l’esecuzione dei modelli a ONNX Runtime, e di Rindow Math Matrix, una libreria di algebra lineare che può appoggiarsi a OpenBLAS. Esiste anche un binding diretto di ONNX Runtime per PHP. Il vantaggio è sfruttare decenni di ottimizzazioni scritte da altri; il prezzo, come abbiamo visto, è la necessità di FFI abilitato e una certa attenzione al confine tra i due mondi.

5. PHP come orchestratore

L’ultimo livello capovolge la prospettiva: PHP non calcola affatto. I modelli girano in servizi specializzati (un server di inferenza locale come Ollama o vLLM, un microservizio Python, un’API cloud) e PHP fa ciò che sa fare meglio: ricevere richieste, gestire utenti e permessi, preparare il contesto, mettere in coda i lavori lunghi, salvare i risultati, presentare l’interfaccia. È il ruolo di framework come Neuron AI, ed è quello che vedremo in dettaglio nella parte dedicata agli agenti.

Quale livello scegliere

Esigenza Livello consigliato
Capire un algoritmo, prototipare, dataset piccoli Array e PHP puro
Modelli classici su dati tabellari dentro l’applicazione Rubix ML
Calcolo numerico intensivo sul proprio server Estensioni (Tensor, NumPower) o BLAS via FFI
Reti neurali pre-addestrate senza servizi esterni ONNX Runtime via FFI (TransformersPHP)
Modelli linguistici di grandi dimensioni, GPU condivise, carichi variabili Servizi di inferenza dedicati, con PHP come orchestratore

Nella pratica i livelli si combinano: la stessa applicazione può calcolare una similarità in PHP puro, classificare un testo con un modello ONNX e affidare la generazione delle risposte a un servizio esterno. La domanda giusta non è “PHP può fare machine learning?”, ma “quale parte del lavoro conviene fare in PHP, e quale delegare?”.

Conclusione

Il benchmark racconta in numeri la storia dell’ecosistema. Gli array di PHP non sono fatti per il calcolo numerico intensivo, e nessuna ottimizzazione del codice cambia questo fatto. Il JIT riduce la distanza, le librerie native la annullano, e lo spostamento dei dati diventa il vero collo di bottiglia. Il ruolo di PHP si è spostato di conseguenza: sempre meno motore di calcolo, sempre più direttore d’orchestra.

Nella prossima parte torneremo però al PHP puro, per costruire da zero uno degli algoritmi più utili e sottovalutati dell’elaborazione del testo: Bag of Words e TF-IDF, con cui un computer trasforma le parole in numeri.


Serie “PHP e intelligenza artificiale” – parte 5 di 8.
← Parte precedente: Modelli neurali dentro PHP con TransformersPHP
Parte successiva: Bag of Words e TF-IDF →