Pour ce 4ème chapitre sur le Machine learning en PHP, abordons le Naive Bayes multinomial. Nous le découvrirons au travers d’un exemple concret : Classer un texte automatiquement en fonction de son thème.
Le machine learning est un domaine de l’intelligence artificielle qui séduit de plus en plus de développeurs et d’entreprises, car il permet de donner aux machines la capacité d’apprendre à partir de données, sans qu’il soit nécessaire de les programmer explicitement pour chaque tâche.
Parmi les nombreux algorithmes existants, le Naive Bayes multinomial occupe une place particulière, car il est à la fois simple, rapide, efficace et très utilisé en traitement automatique du langage naturel, c’est-à-dire l’analyse et la compréhension des textes.
Dans ce chapitre, nous allons plonger en profondeur dans le monde du Naive Bayes multinomial. Nous verrons ce qu’il est, à quoi il sert, quels sont ses avantages et ses limites, mais aussi quand l’utiliser.
Nous utiliserons pour cela une bibliothèque de machine learning en PHP, afin de rendre ce tutoriel accessible à celles et ceux d’entre vous qui maîtrisent déjà ce langage mais souhaitent découvrir l’intelligence artificielle.
L’objectif est de vous fournir une ressource complète, structurée et facile à suivre. Même si vous n’avez jamais entendu parler du machine learning auparavant, vous serez en mesure, à la fin de ce tutoriel, de comprendre le Naive Bayes multinomial et de l’utiliser dans un projet réel.
- Qu’est-ce que le Naive Bayes multinomial ?
- À quoi sert le Naive Bayes multinomial ?
- Les avantages du Naive Bayes multinomial
- Quand utiliser le Naive Bayes multinomial ?
- Exemple pratique en PHP : Classer un texte automatiquement par thème
- Tester plusieurs textes
- Évaluer les performances du modèle
- Prétraiter le texte pour améliorer le Naive Bayes multinomial
- Exemple complet avec prétraitement
- le Naive Bayes multinomial, une porte d’entrée efficace au Machine learning
Qu’est-ce que le Naive Bayes multinomial ?
Pour comprendre le Naive Bayes multinomial, commençons par revenir à ses bases. Il s’agit d’un algorithme de classification supervisée. Cela signifie qu’il apprend à partir d’exemples déjà étiquetés afin de prédire la catégorie d’une nouvelle donnée.
Si nous lui montrons un grand nombre de textes déjà classés comme étant du sport, de la politique ou de la technologie, il sera capable, après entraînement, de prédire dans quelle catégorie ranger un texte jamais vu auparavant.
Le terme « Naive Bayes » fait référence à deux idées principales :
- Bayes, car l’algorithme repose sur le théorème de Bayes, une formule statistique qui permet de calculer la probabilité qu’un événement se produise, en tenant compte d’informations connues. Ce théorème nous dit, en simplifiant, que la probabilité qu’un texte appartienne à une catégorie dépend de la probabilité d’observer certains mots dans cette catégorie.
- Naive, qui signifie « naïf » en anglais, car l’algorithme part d’une hypothèse simplificatrice : il considère que les mots dans un texte sont indépendants les uns des autres. Bien sûr, dans la réalité, les mots ne sont pas complètement indépendants (par exemple, le mot « ballon » a plus de chances d’être suivi par « football » que par « parlement »), mais cette simplification rend le calcul beaucoup plus simple et, étonnamment, l’algorithme reste très performant.
Enfin, l’appellation « multinomial » indique que nous travaillons sur des données représentées comme des distributions de fréquences de mots. Chaque texte est transformé en une sorte de vecteur indiquant combien de fois chaque mot apparaît, et l’algorithme utilise ces fréquences pour calculer les probabilités.
À quoi sert le Naive Bayes multinomial ?
Le Naive Bayes multinomial est particulièrement utile dans le traitement du langage naturel. Voici quelques-unes de ses principales applications :
- Filtrage de spam : il peut apprendre à distinguer les emails indésirables des messages légitimes, en fonction des mots qu’ils contiennent.
- Analyse de sentiments : il est capable de déterminer si un avis en ligne est plutôt positif, négatif ou neutre.
- Classification de documents : il permet de classer automatiquement des articles, des blogs ou des nouvelles dans des thématiques définies, comme nous allons le faire avec sport, politique et technologie.
- Recherche d’information : il peut aider à organiser de grandes quantités de textes pour rendre leur exploration plus efficace.
Dès que vous avez des textes à analyser et que vous souhaitez les organiser automatiquement en catégories, le Naive Bayes multinomial est un outil précieux.
Les avantages du Naive Bayes multinomial
Pourquoi utiliser cet algorithme plutôt qu’un autre ? Voici ses principaux avantages :
- Simplicité : le Naive Bayes multinomial est facile à comprendre et à implémenter. Même si vous débutez en machine learning, vous pouvez rapidement le mettre en pratique.
- Rapidité : son entraînement est extrêmement rapide, même sur de grandes bases de données.
- Efficacité : malgré son hypothèse « naïve » d’indépendance des mots, il obtient souvent des résultats très bons dans la classification de textes.
- Peu gourmand en ressources : il ne nécessite pas de machines puissantes ni de temps de calcul important, contrairement à d’autres modèles comme les réseaux de neurones.
- Robustesse face aux données manquantes : il gère relativement bien les cas où certaines informations ne sont pas disponibles.
Ces qualités en font un algorithme privilégié pour les premiers pas en machine learning, mais aussi pour des systèmes en production qui doivent être rapides et efficaces.
Les limites du Naive Bayes multinomial
Comme tout algorithme, il n’est pas parfait et présente certaines limites qu’il est important de connaître :
- Hypothèse d’indépendance : l’idée que les mots soient indépendants les uns des autres est irréaliste. Cela peut réduire sa précision dans certains contextes.
- Manque de prise en compte du sens : le Naive Bayes multinomial se base uniquement sur la fréquence des mots, pas sur leur signification ni sur leur ordre. Il ne peut donc pas comprendre des nuances de sens ou des relations complexes entre les termes.
- Sensibilité aux données déséquilibrées : si une catégorie est surreprésentée dans les données d’entraînement, l’algorithme aura tendance à la privilégier.
- Performances limitées face à d’autres modèles : dans des tâches complexes, comme la traduction automatique ou la génération de texte, d’autres méthodes plus avancées (comme les réseaux de neurones ou les transformers) sont bien plus performantes.
Connaître ces limites vous permet de mieux choisir quand utiliser cet algorithme, et surtout de ne pas attendre de lui plus que ce qu’il peut offrir.
Quand utiliser le Naive Bayes multinomial ?
Le Naive Bayes multinomial est particulièrement adapté lorsque :
- Vous devez classer des textes courts ou moyens en plusieurs catégories.
- Vous disposez d’un volume relativement important de données déjà étiquetées.
- Vous avez besoin d’un algorithme rapide, peu gourmand en ressources et facile à mettre en place.
- Vous débutez dans le machine learning et vous cherchez un algorithme à la fois pédagogique et efficace.
Il est moins recommandé lorsque le sens et l’ordre des mots sont cruciaux, par exemple dans l’analyse syntaxique ou dans les tâches qui nécessitent de comprendre la structure complète d’une phrase.
Exemple pratique en PHP : Classer un texte automatiquement par thème
Contrairement à Python qui dispose d’outils très connus comme scikit-learn, le machine learning en PHP reste moins répandu. Cependant, il existe des bibliothèques que nous pouvons exploiter. Pour notre projet, nous allons utiliser PHP-ML (PHP Machine Learning), une bibliothèque open source qui propose plusieurs algorithmes, dont le Naive Bayes multinomial.
Pour l’installer, vous devez utiliser Composer, le gestionnaire de dépendances de PHP.
Si vous ne l’avez pas encore installé, rendez-vous sur https://getcomposer.org et suivez les instructions.
Ensuite, installez PHP-ML avec la commande suivante dans votre terminal à la racine de votre projet :
composer require php-ai/php-mlCela ajoutera la bibliothèque dans votre projet et la rendra accessible via l’autoload de Composer.
Étape 1 : Préparer nos données d’entraînement
L’algorithme Naive Bayes multinomial apprend à partir d’exemples. Nous devons donc lui fournir un ensemble de textes déjà classés dans les trois catégories.
Imaginons un petit jeu de données pour commencer. Nous allons créer un script PHP nommé naive_bayes.php et y insérer le code suivant :
<?php
require 'vendor/autoload.php';
use Phpml\Classification\NaiveBayes;
// Étape 1 : Préparation des données
$samples = [
// Sport
['football match équipe ballon'],
['le joueur a marqué un but'],
['la compétition sportive commence'],
['match de tennis gagné'],
['tournoi de basketball professionnel'],
// Politique
['le président a fait un discours'],
['nouvelle réforme politique annoncée'],
['le parlement vote une loi'],
['le gouvernement débat du budget'],
['campagne électorale en cours'],
// Technologie
['nouveau smartphone lancé'],
['avancées en intelligence artificielle'],
['l’entreprise développe un logiciel'],
['ordinateur portable performant'],
['cybersécurité et protection des données']
];
$labels = [
'sport', 'sport', 'sport', 'sport', 'sport',
'politique', 'politique', 'politique', 'politique', 'politique',
'technologie', 'technologie', 'technologie', 'technologie', 'technologie'
];Ici :
$samplescontient les textes d’exemple, chacun représenté sous forme de tableau de mots.$labelscontient les catégories correspondantes : sport, politique ou technologie.
Ce jeu de données est volontairement petit pour l’exemple, mais dans un projet réel vous utiliserez un corpus beaucoup plus large.
Étape 2 : Entraîner le modèle
Maintenant que nous avons nos données, nous pouvons entraîner notre classificateur Naive Bayes :
// Étape 2 : Création et entraînement du modèle
$classifier = new NaiveBayes();
$classifier->train($samples, $labels);La méthode train apprend à partir des exemples fournis.
Étape 3 : Tester le modèle avec un texte
Une fois le modèle entraîné, testons-le avec un nouveau texte.
// Étape 3 : Prédiction sur un nouveau texte
$texte = ['match de football professionnel'];
$prediction = $classifier->predict($texte);
echo "Le texte est classé dans la catégorie : " . $prediction . "\n";Si vous exécutez ce script, vous devriez obtenir la sortie :
Le texte est classé dans la catégorie : sportTester plusieurs textes
Nous pouvons aussi tester plusieurs phrases d’un coup :
<?php
require 'vendor/autoload.php';
use Phpml\Classification\NaiveBayes;
use Phpml\FeatureExtraction\TokenCountVectorizer;
use Phpml\Tokenization\WhitespaceTokenizer;
// 1. Préparer les données brutes
$samples = [
'football match équipe ballon',
'le joueur a marqué un but',
'la compétition sportive commence',
'match de tennis gagné',
'tournoi de basketball professionnel',
'le président a fait un discours',
'nouvelle réforme politique annoncée',
'le parlement vote une loi',
'le gouvernement débat du budget',
'campagne électorale en cours',
'nouveau smartphone lancé',
'avancées en intelligence artificielle',
'l’entreprise développe un logiciel',
'ordinateur portable performant',
'cybersécurité et protection des données'
];
$labels = [
'sport','sport','sport','sport','sport',
'politique','politique','politique','politique','politique',
'technologie','technologie','technologie','technologie','technologie'
];
// 2. Transformer les textes en vecteurs
$vectorizer = new TokenCountVectorizer(new WhitespaceTokenizer());
$vectorizer->fit($samples); // construit le vocabulaire
$vectorizer->transform($samples); // transforme chaque phrase en vecteur fixe
// 3. Entraîner le modèle
$classifier = new NaiveBayes();
$classifier->train($samples, $labels);
// 4. Prédiction
$originalTests = [
'nouvelle loi adoptée par le parlement',
'ordinateur portable puissant',
'joueur de tennis gagne un titre'
];
// Transformer en vecteurs
$vectorizedTests = $originalTests; // copie pour transformer
$vectorizer->transform($vectorizedTests);
foreach ($vectorizedTests as $i => $vecteur) {
$prediction = $classifier->predict([$vecteur]);
echo $originalTests[$i] . " => " . $prediction[0] . "\n<br>";
}Sortie attendue :
nouvelle loi adoptée par le parlement => politique
ordinateur portable puissant => technologie
joueur de tennis gagne un titre => sportLes labels
$labels = [
'sport','sport','sport','sport','sport',
'politique','politique','politique','politique','politique',
'technologie','technologie','technologie','technologie','technologie'
];Ici, $labels est un tableau qui contient la catégorie de chaque phrase que vous voulez classifier. Chaque élément correspond à une phrase dans votre tableau $samples. Par exemple, si votre premier échantillon $samples[0] est 'football match équipe ballon', le label correspondant est 'sport'.
Ainsi, le modèle saura que cette phrase appartient à la catégorie « sport ».
Les labels sont les réponses correctes pour l’apprentissage du modèle.
Transformer les textes en vecteurs
$vectorizer = new TokenCountVectorizer(new WhitespaceTokenizer());
$vectorizer->fit($samples); // construit le vocabulaire
$vectorizer->transform($samples); // transforme chaque phrase en vecteur fixeLe classificateur NaiveBayes ne peut pas travailler directement avec des phrases en texte brut. Il a besoin de vecteurs numériques, c’est-à-dire des listes de nombres qui représentent les mots présents dans chaque phrase. TokenCountVectorizer fait ce travail. Voici comment :
Tokenization : le WhitespaceTokenizer() découpe chaque phrase en mots (tokens) en séparant par les espaces.
Exemple : 'le joueur a marqué un but' devient ['le', 'joueur', 'a', 'marqué', 'un', 'but'].
Fit : $vectorizer->fit($samples) analyse tous vos échantillons pour construire un vocabulaire, c’est-à-dire la liste de tous les mots uniques présents dans vos phrases.
Transform : $vectorizer->transform($samples) transforme chaque phrase en un vecteur numérique. Chaque vecteur a la même longueur, correspondant à la taille du vocabulaire. Chaque position du vecteur indique combien de fois le mot correspondant apparaît dans la phrase.
Des formations informatique pour tous !
Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…
Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.
Découvrez mes formations Qui suis-je ?Cette étape prépare vos textes pour que le modèle puisse les comprendre.
Entraîner le modèle
$classifier = new NaiveBayes();
$classifier->train($samples, $labels);- Ici, vous créez un classificateur Naive Bayes, un algorithme de machine learning très simple pour classer des textes.
- La méthode
train()permet au modèle d’apprendre à partir de vos données :$samples: vos phrases transformées en vecteurs.$labels: la catégorie correspondante à chaque phrase.
- Après l’entraînement, le modèle sait quelle catégorie est la plus probable pour chaque combinaison de mots.
Prédiction sur de nouvelles phrases
$originalTests = [
'nouvelle loi adoptée par le parlement',
'ordinateur portable puissant',
'joueur de tennis gagne un titre'
];
// Transformer en vecteurs
$vectorizedTests = $originalTests; // copie pour transformer
$vectorizer->transform($vectorizedTests);$originalTests contient de nouvelles phrases que vous voulez classifier. Comme précédemment, le modèle ne peut pas lire du texte brut, il faut donc transformer ces phrases en vecteurs grâce au vectorizer.
On fait une copie pour garder les textes originaux afin de les afficher plus tard.
Affichage des résultats
foreach ($vectorizedTests as $i => $vecteur) {
$prediction = $classifier->predict([$vecteur]);
echo $originalTests[$i] . " => " . $prediction[0] . "\n<br>";
}On parcourt chaque vecteur de test. predict([$vecteur]) retourne la catégorie prédite pour ce vecteur. Même pour une seule phrase, predict() renvoie un tableau, donc on prend l’élément [0].
On affiche ensuite le texte original suivi de sa prédiction :
Exemple : ordinateur portable puissant => technologie
- Vous avez des phrases d’apprentissage avec leur catégorie (labels).
- Vous transformez les phrases en vecteurs numériques que le modèle peut utiliser.
- Vous entraînez le modèle pour qu’il apprenne à associer des mots à des catégories.
- Vous pouvez maintenant prédire la catégorie de nouvelles phrases et les afficher correctement.
Évaluer les performances du modèle
Un modèle n’a de valeur que si l’on sait mesurer sa qualité. Pour un classificateur comme le Naive Bayes multinomial, il existe plusieurs métriques utiles :
- La précision (accuracy) : proportion de bonnes réponses sur le total.
- La précision par classe (precision) : combien de fois le modèle a raison lorsqu’il prédit une catégorie donnée.
- Le rappel (recall) : combien de fois le modèle retrouve correctement les éléments d’une catégorie donnée.
- La F-mesure (F1-score) : une moyenne harmonique entre précision et rappel, utile lorsque les catégories ne sont pas équilibrées.
Mise en place avec PHP-ML
La bibliothèque PHP-ML propose une classe Accuracy pour calculer la précision globale.
Modifions notre script pour évaluer les résultats :
<?php
require 'vendor/autoload.php';
use Phpml\Classification\NaiveBayes;
use Phpml\FeatureExtraction\TokenCountVectorizer;
use Phpml\Tokenization\WhitespaceTokenizer;
use Phpml\Metric\Accuracy;
// 1. Préparer les données brutes
$samples = [
'football match équipe ballon',
'le joueur a marqué un but',
'la compétition sportive commence',
'match de tennis gagné',
'tournoi de basketball professionnel',
'le président a fait un discours',
'nouvelle réforme politique annoncée',
'le parlement vote une loi',
'le gouvernement débat du budget',
'campagne électorale en cours',
'nouveau smartphone lancé',
'avancées en intelligence artificielle',
'l’entreprise développe un logiciel',
'ordinateur portable performant',
'cybersécurité et protection des données'
];
$labels = [
'sport','sport','sport','sport','sport',
'politique','politique','politique','politique','politique',
'technologie','technologie','technologie','technologie','technologie'
];
// 2. Transformer les textes en vecteurs pour l'apprentissage
$vectorizer = new TokenCountVectorizer(new WhitespaceTokenizer());
$vectorizer->fit($samples);
$vectorizer->transform($samples);
// 3. Entraîner le modèle
$classifier = new NaiveBayes();
$classifier->train($samples, $labels);
// 4. Définir les tests et labels attendus
$tests = [
'le président parle au parlement',
'ordinateur gaming rapide',
'but marqué pendant le match',
'réforme fiscale annoncée',
'nouvelle technologie en cybersécurité'
];
$expected = [
'politique',
'technologie',
'sport',
'politique',
'technologie'
];
// Transformer en vecteurs
$vectorizedTests = $tests;
$vectorizer->transform($vectorizedTests);
// Prédictions du modèle
$predicted = $classifier->predict($vectorizedTests);
// Calcul de la précision
$accuracy = Accuracy::score($expected, $predicted);
echo "Précision du modèle : " . ($accuracy * 100) . "%\n";Si vous exécutez ce script, vous obtiendrez une valeur comme :
Précision du modèle : 80%Cela signifie que sur l’ensemble de test choisi, le modèle a classé correctement 4 textes sur 5.
Aller plus loin avec l’évaluation
Dans un vrai projet, vous pourriez aller plus loin en utilisant :
- La validation croisée : diviser vos données en plusieurs parties et entraîner plusieurs fois le modèle pour une évaluation plus fiable.
- La matrice de confusion : un tableau qui montre combien de fois chaque catégorie a été prédite correctement ou incorrectement.
PHP-ML propose certaines de ces fonctionnalités, mais vous pouvez aussi les coder vous-même pour mieux comprendre le comportement du modèle.
Prétraiter le texte pour améliorer le Naive Bayes multinomial
Dans notre exemple précédent, nous avons fourni des phrases brutes au classifieur. Cela fonctionne, mais ce n’est pas optimal. En réalité, un texte contient de nombreux éléments inutiles ou parasites qui risquent de brouiller les calculs de probabilité. Pour obtenir de meilleures performances, il est indispensable de transformer vos textes en données propres et pertinentes.
Pourquoi prétraiter les textes ?
Lorsque vous entraînez un modèle de Machine learning en traitement automatique du langage, les mots sont vos variables d’entrée. Si vos phrases contiennent beaucoup de variations ou de mots vides, votre modèle va se retrouver avec :
- Trop de dimensions (chaque mot différent crée une nouvelle “case” dans vos vecteurs).
- Trop de bruit (par exemple, des mots comme “le”, “de”, “et” apparaissent partout, dans toutes les catégories).
- Trop de formes différentes pour le même mot (par exemple, “jouer”, “jouait”, “jouera” renvoient tous à la même idée, mais le modèle les voit comme des mots distincts).
Un bon prétraitement permet donc de :
- Réduire le bruit.
- Standardiser les données.
- Améliorer la généralisation.
Les principales étapes du prétraitement
Il existe plusieurs techniques que nous allons expliquer une par une, avec leur utilité et comment les mettre en place en PHP.
Mettre tout en minuscules
Un texte peut contenir des majuscules qui ne changent pas le sens mais créent des doublons dans les données. Par exemple, “Football” et “football” seraient considérés comme deux mots différents.
En PHP, on utilise simplement :
$texte = strtolower($texte);Supprimer la ponctuation et les caractères spéciaux
La ponctuation n’apporte pas d’information utile pour ce type de classification. On peut la supprimer avec une expression régulière :
$texte = preg_replace('/[^\p{L}\p{N}\s]/u', ' ', $texte);Ici, on ne garde que les lettres, les chiffres et les espaces.
Supprimer les mots vides (stopwords)
Les mots très fréquents comme “le”, “et”, “de”, “à” n’apportent aucune valeur discriminante entre “sport”, “politique” ou “technologie”. Ce sont les fameux stopwords.
En PHP, vous pouvez créer une petite liste de mots à exclure, par exemple :
$stopwords = ['le','la','les','et','de','des','un','une','à','en','du','dans','au'];Puis les filtrer :
$mots = explode(" ", $texte);
$mots = array_diff($mots, $stopwords);
$texte = implode(" ", $mots);Lemmatisation ou racinisation
La lemmatisation (ou stemming) consiste à ramener un mot à sa racine. Par exemple :
- “joue”, “jouait”, “jouera” → “jouer”
- “politiques”, “politicien” → “politique”
En PHP, il n’existe pas encore de bibliothèque aussi puissante que NLTK en Python, mais vous pouvez :
- Soit utiliser des règles simples (enlever les “s” du pluriel, réduire les conjugaisons basiques).
- Soit utiliser des librairies externes comme PHP NLP Tools (moins complètes que leurs équivalents Python, mais utiles).
Transformation TF-IDF (option avancée)
Jusqu’à présent, nous avons compté simplement le nombre d’occurrences des mots. Mais certains mots fréquents comme “match” dans le sport ou “loi” en politique risquent de dominer les vecteurs.
La transformation TF-IDF (Term Frequency – Inverse Document Frequency) pondère les mots pour donner plus de poids à ceux qui sont rares et distinctifs.
Dans PHP-ML, cela se fait facilement en utilisant TfIdfTransformer :
use Phpml\FeatureExtraction\TfIdfTransformer;
$vectorizer = new TokenCountVectorizer(new WhitespaceTokenizer());
$vectorizer->fit($samples);
$vectorizer->transform($samples);
// Appliquer TF-IDF
$tfIdfTransformer = new TfIdfTransformer($samples);
$tfIdfTransformer->transform($samples);Exemple complet avec prétraitement
Voici un code qui applique toutes ces étapes avant d’entraîner le modèle :
<?php
require 'vendor/autoload.php';
use Phpml\Classification\NaiveBayes;
use Phpml\FeatureExtraction\TokenCountVectorizer;
use Phpml\FeatureExtraction\TfIdfTransformer;
use Phpml\Tokenization\WhitespaceTokenizer;
use Phpml\Dataset\ArrayDataset;
function nettoyerTexte($texte) {
$stopwords = ['le','la','les','et','de','des','un','une','à','en','du','dans','au'];
$texte = strtolower($texte);
$texte = preg_replace('/[^\p{L}\p{N}\s]/u', ' ', $texte);
$mots = explode(" ", $texte);
$mots = array_diff($mots, $stopwords);
return implode(" ", $mots);
}
$samples = [
nettoyerTexte("Le joueur a marqué un but décisif lors du match"),
nettoyerTexte("L'équipe nationale a remporté la coupe"),
nettoyerTexte("Le gouvernement a adopté une nouvelle loi"),
nettoyerTexte("Le président a tenu un discours important"),
nettoyerTexte("Une nouvelle intelligence artificielle a été présentée"),
nettoyerTexte("Les chercheurs ont développé une technologie innovante")
];
$labels = ["sport", "sport", "politique", "politique", "technologie", "technologie"];
// Vectorisation + TF-IDF
$vectorizer = new TokenCountVectorizer(new WhitespaceTokenizer());
$vectorizer->fit($samples);
$vectorizer->transform($samples);
$tfIdfTransformer = new TfIdfTransformer($samples);
$tfIdfTransformer->transform($samples);
// Créer le dataset et entraîner
$dataset = new ArrayDataset($samples, $labels);
$classifier = new NaiveBayes();
$classifier->train($dataset->getSamples(), $dataset->getTargets());
// Texte à tester
$texteOriginal = "Le ministre annonce une nouvelle réforme économique";
$test = [nettoyerTexte($texteOriginal)];
// Transformation en vecteur
$vectorizer->transform($test);
$tfIdfTransformer->transform($test);
// Prédiction
$prediction = $classifier->predict($test);
// Affichage
echo "Texte testé : " . $texteOriginal . PHP_EOL;
echo "Catégorie prédite : " . $prediction[0] . PHP_EOL;Avec ce script, vous avez désormais un classifieur beaucoup plus robuste, car les textes sont nettoyés, standardisés, et pondérés grâce à TF-IDF.
le Naive Bayes multinomial, une porte d’entrée efficace au Machine learning
Vous venez de parcourir un chemin complet, depuis la découverte théorique du Naive Bayes multinomial jusqu’à sa mise en pratique concrète pour classifier des textes en catégories simples comme “sport”, “politique” et “technologie”.
Ce voyage montre à quel point cet algorithme est à la fois accessible et puissant.
Derrière une formule mathématique très élégante se cache un outil particulièrement adapté au traitement automatique du langage. Bien sûr, ce n’est pas l’algorithme parfait : il simplifie les relations entre les mots en supposant leur indépendance, et peut donc échouer dans des contextes complexes où la sémantique joue un rôle important. Mais son avantage principal réside dans sa rapidité, sa simplicité et son efficacité sur des jeux de données textuelles bien préparés.
Vous avez vu aussi l’importance du prétraitement des données. Un texte brut ne suffit pas : il faut nettoyer, normaliser, réduire le bruit et parfois pondérer les mots avec des techniques comme TF-IDF. C’est ce travail invisible mais essentiel qui transforme un modèle basique en un outil réellement pertinent.
Ce chapitre a également démontré qu’il est possible de faire du Machine learning en PHP, grâce à des bibliothèques comme PHP-ML. Certes, la communauté PHP autour du Machine learning est moins développée que celle de Python, mais pour un projet web, un prototype rapide ou un environnement purement PHP, c’est une solution viable et enrichissante.
L’essentiel à retenir est que le Naive Bayes multinomial n’est pas une fin en soi mais une porte d’entrée. Une fois que vous le maîtrisez, vous pouvez explorer des méthodes plus avancées, comparer ses performances avec d’autres algorithmes (comme les SVM, les réseaux neuronaux ou les forêts aléatoires), ou encore améliorer vos modèles avec des jeux de données massifs et des pipelines de traitement plus sophistiqués.
Enfin, au-delà du code et des concepts, il faut garder en tête que le Machine learning n’est jamais magique : il repose sur vos données, leur qualité, leur diversité et la façon dont vous les préparez. C’est là que réside la vraie valeur.
En somme, le Naive Bayes multinomial est un excellent premier pas pour comprendre le Machine learning appliqué aux textes. Simple, clair et efficace, il vous donne les clés pour aller plus loin, expérimenter et construire des projets concrets, qu’il s’agisse de classer des articles de presse, filtrer des emails ou analyser des avis clients.
