TransformersPHP : transformers en PHP sans Python

# TransformersPHP en PHP : Inférence locale des Transformers pour le backend

TransformersPHP vous permet d'exécuter des modèles transformer pré-entraînés comme BERT et DistilBERT directement dans des applications PHP via ONNX Runtime. La bibliothèque permet l'inférence locale sans Python, sans API réseau ni services externes. Elle gère les tâches d'embedding, la classification de texte et la recherche sémantique avec des temps de réponse prévisibles et un contrôle total des données.

Avantages clés pour le backend : absence de latence due aux appels réseau, mode hors ligne après chargement du modèle, confidentialité des données. Elle prend en charge les tâches NLP standard — de l'analyse de sentiment à la similarité sémantique.

Exigences et configuration de l'environnement

Pour démarrer, vous aurez besoin de PHP 8.1+, Composer, l'extension FFI et ONNX Runtime. JIT est recommandé pour de meilleures performances, ainsi qu'une memory_limit augmentée.

Structure du projet :

/project/
  ├── app/
  │    ├── demo.php
  │    ├── semantic-search.php
  ├── docker/
  │    ├── Dockerfile
  ├── docker-compose.yml
  ├── composer.json

L'installation via Docker simplifie le déploiement. Fichier composer.json :

{
    "type": "project",
    "minimum-stability": "stable",
    "prefer-stable": true,
    "require": {
        "codewithkyrian/transformers": "~0.6.2"
    },
    "config": {
        "allow-plugins": {
            "codewithkyrian/platform-package-installer": true
        }
    }
}

Commandes à exécuter :

• docker compose build --pull
• docker compose up -d
• docker compose exec app composer install

Le Dockerfile configure FFI, ONNX Runtime 1.17.1, et les extensions PHP (zip, pdo_mysql, bcmath, ffi, et autres).

Premier exemple : Analyse de sentiment

La démo basique illustre l'API pipeline. Créez app/demo.php :

require_once __DIR__ . '/../vendor/autoload.php';

use function Codewithkyrian\Transformers\Pipelines\pipeline;

// Konveyer for sentiment-analysis
$classifier = pipeline('sentiment-analysis');

$out = $classifier(['I love transformers!']);
echo 'I love transformers!\n';
echo print_r($out, true);

$out = $classifier(['I hate transformers!']);
echo 'I hate transformers!\n';
echo print_r($out, true);

Exécutez : docker compose exec app php app/demo.php

Sortie :

I love transformers!
Array ( 
  [label] => POSITIVE 
  [score] => 0.99978870153427 
)

I hate transformers!
Array ( 
  [label] => NEGATIVE 
  [score] => 0.99863630533218 
)

La pipeline abstrait le chargement du modèle, la tokenisation et l'inférence. Le premier appel met en cache le modèle.

Recherche sémantique pour les événements

Scénario concret : recherche sémantique dans un flux d'événements. Les textes des événements ne contiennent pas la formulation exacte de la requête (synonymes, morphologie).

Données d'exemple :

• Nouvelles restrictions introduites concernant les corporations technologiques
• Les pays de la région augmentent leurs investissements dans les programmes spatiaux
• Escalade du conflit pour des motifs politiques

Requête : « course à l'espace entre pays de la région ».

Solution via embeddings : représentations vectorielles des textes, similarité cosinus pour le classement.

Exécutez l'exemple : docker compose exec app php app/semantic-search.php

Le code utilise pipeline('feature-extraction') pour les embeddings et calcule la similarité sémantique sans mots-clés.

Rôle architectural dans le backend PHP

TransformersPHP s'intègre comme un service dans un monolithe ou un microservice :

• Génération d'embeddings pour la recherche
• Classification de logs/requêtes
• Détection de doublons
• NER local sans API

// Example integration in servis
class SemanticSearchService {
    private $embedder;
    
    public function __construct() {
        $this->embedder = pipeline('feature-extraction');
    }
    
    public function findSimilar(string $query, array $documents): array {
        // Embeddingi + cosine similarity
    }
}

Avantages par rapport aux API :

• Latence stable (<100ms sur CPU)
• Pas de quotas/coûts
• Hors ligne après initialisation
• Contrôle total du modèle

Optimisation des performances

• JIT en PHP 8.2+ accélère l'inférence de 20-30%
• Mise en cache des modèles en Redis
• Groupage des requêtes
• Optimisations ONNX (quantization)

Testé sur DistilBERT : ~50ms pour un embedding de 512 tokens (i7, 16GB).

Pour la production : surveillance de la mémoire (modèles 100-500MB), fallback gracieux vers une API.

Points clés à retenir

• TransformersPHP — pour l'inférence, pas pour l'entraînement de modèles.
• L'inférence locale résout 80% des tâches NLP backend sans data science.
• S'intègre comme un package Composer, sans infrastructure Python.
• Adapté aux environnements sensibles à la confidentialité (GDPR).
• Scalable via groupage et mise en cache.

— Editorial Team