Machine learning PHP : Fréquence passée et prédiction

Pour ce 5eme chapitre de notre tutoriel complet sur le Machine learning en PHP, nous allons découvrir comment prédire l’issue d’un lancer de pile ou face. Vous apprendrez à exploiter a fréquence passée pour estimer la prochaine valeur et comprendrez comment ces méthodes simples peuvent servir de base pour des modèles plus complexes.

Même si prédire un lancer de pile ou face peut sembler inutile, ce type d’exemple est parfait pour apprendre les principes du Machine learning, du approfondir le clustering, et les statistiques. Nous allons procéder pas à pas, avec des explications claires pour que même un débutant en PHP et en Machine learning puisse suivre.

Nous aborderons également les concepts essentiels : à quoi servent les fréquences passées, leurs avantages et limites, ainsi que la manière de les exploiter pour des prédictions simples.

Qu’est-ce que qu’une fréquence passée ?

Les fréquences passées sont tout simplement la proportion ou le nombre de fois qu’un événement s’est produit dans le passé.

Dans notre exemple du pile ou face, on pourrait suivre combien de fois le résultat a été « pile » et combien de fois il a été « face ».

En statistique, ce concept est très utilisé pour estimer la probabilité qu’un événement se reproduise. Si, sur 100 lancers, vous avez obtenu 60 fois pile et 40 fois face, la fréquence passée indique que la prochaine probabilité de tomber sur pile pourrait être estimée à 60%.

Le calcul des fréquences passées est relativement simple. Il consiste à compter le nombre de fois que chaque résultat s’est produit et à le diviser par le nombre total d’observations. Cela donne une première estimation probabiliste.

Les fréquences passées sont souvent utilisées comme baseline pour des modèles plus avancés de Machine learning. Elles permettent de détecter des tendances, même légères, et d’alimenter des algorithmes qui vont essayer de prédire le futur à partir du passé.

À quoi sert une fréquence passé ?

Les fréquences passées sont utiles pour plusieurs raisons. Premièrement, elles permettent d’avoir une estimation rapide d’un phénomène sans utiliser de modèles complexes. Dans notre exemple, elles peuvent donner une idée du prochain résultat d’un lancer de pile ou face.

Ensuite, elles servent de données d’entrée pour des modèles de Machine learning plus élaborés. Par exemple, dans un système de clustering, les fréquences passées peuvent être utilisées comme vecteurs numériques représentant l’historique d’un joueur ou d’un événement. Cela permet de regrouper les comportements similaires et de mieux prédire leurs actions futures.

Enfin, elles peuvent servir dans des simulations ou des tests statistiques pour comprendre des comportements aléatoires, vérifier des hypothèses, ou tester des stratégies simples avant de passer à des modèles plus complexes.

Avantages et limites des fréquences passées

Les avantages sont multiples. Elles sont faciles à calculer et à comprendre. Même un débutant peut rapidement mettre en place un script PHP qui calcule ces fréquences. Elles sont également utiles pour fournir une estimation initiale avant d’appliquer des modèles plus sophistiqués.

Cependant, les fréquences passées ont des limites importantes. Elles supposent que le passé influence directement le futur, ce qui n’est pas toujours vrai. Dans notre exemple du pile ou face, chaque lancer est indépendant : le résultat d’un lancer n’affecte pas le suivant. Cela signifie que se baser uniquement sur les fréquences passées n’est pas fiable pour des événements strictement aléatoires.

De plus, si l’échantillon de données est trop petit, les fréquences peuvent être trompeuses. Par exemple, si vous n’avez que 10 lancers, la fréquence de pile pourrait être de 70%, ce qui ne reflète pas la réalité statistique.

Quand utiliser les fréquences passées ?

Les fréquences passées sont particulièrement utiles lorsque les événements ne sont pas strictement indépendants et que des tendances peuvent se dessiner. Par exemple, pour prédire les comportements des utilisateurs sur un site web, les ventes d’un produit ou l’apparition de certains mots dans un texte, les fréquences passées peuvent donner un signal intéressant.

Dans le contexte du Machine learning, elles servent souvent de feature simple et efficace pour enrichir un dataset. Elles sont un point de départ idéal pour les débutants qui veulent comprendre comment un modèle peut apprendre à partir de données historiques.

Pour notre exemple de pile ou face, même si les lancers sont indépendants, utiliser les fréquences passées permet de montrer concrètement comment structurer un modèle et préparer des données pour un algorithme de Machine learning.

Prédire pile ou face en PHP avec les fréquences passées

Pour ce chapitre, nous allons utiliser la bibliothèque Php-ml. C’est une librairie simple, bien documentée, adaptée aux débutants, et elle permet de créer facilement des modèles de Machine learning en PHP.

Elle inclut plusieurs algorithmes, dont ceux pour la classification, qui est exactement ce dont nous avons besoin pour prédire « pile » ou « face ».

Pour l’installer, utilisez Composer :

composer require php-ai/php-ml

Cela va télécharger Php-ml et ses dépendances dans votre projet.

Préparer les données : calculer les fréquences passées

Pour commencer, nous allons simuler une série de lancers de pile ou face. Ensuite, nous calculerons la fréquence passée de chaque résultat afin de nourrir notre modèle.

Voici un exemple de code commenté :

<?php

require 'vendor/autoload.php';

use Phpml\Classification\KNearestNeighbors;

// 1. Créons un historique de lancers : 'pile' = 1, 'face' = 0
$historique = [1, 0, 1, 1, 0, 1, 0, 0, 1, 1];

// 2. Calculons la fréquence passée de 'pile' et 'face'
$nombrePile = count(array_filter($historique, fn($val) => $val === 1));
$nombreFace = count(array_filter($historique, fn($val) => $val === 0));
$total = count($historique);

$frequencePile = $nombrePile / $total; // Ex : 0.6 si 6 piles sur 10 lancers
$frequenceFace = $nombreFace / $total; // Ex : 0.4

echo "Fréquence de pile : $frequencePile\n";
echo "Fréquence de face : $frequenceFace\n";

Explications :

array_filter nous permet de compter combien de fois un résultat apparaît dans notre historique.

$frequencePile et $frequenceFace représentent la probabilité de tomber sur pile ou face selon les lancers passés.

Ici, on ne cherche pas encore à prédire avec un algorithme, mais à préparer une feature utilisable pour notre modèle.

Créer le modèle de Machine learning

Pour prédire le prochain lancer, nous allons utiliser un modèle simple de K-Nearest Neighbors (KNN). Cet algorithme regarde les points les plus proches dans notre historique et prédit la classe la plus fréquente.

<?php

// 3. Préparer les données pour le modèle
// Chaque point contient la fréquence passée de pile et face
$donnees = [];
$labels = [];

for ($i = 1; $i < count($historique); $i++) {
    $sousHistorique = array_slice($historique, 0, $i);
    $nombrePile = count(array_filter($sousHistorique, fn($val) => $val === 1));
    $nombreFace = count(array_filter($sousHistorique, fn($val) => $val === 0));
    $total = count($sousHistorique);

    $frequencePile = $nombrePile / $total;
    $frequenceFace = $nombreFace / $total;

    $donnees[] = [$frequencePile, $frequenceFace];
    $labels[] = $historique[$i]; // le vrai résultat suivant
}

// 4. Créer le modèle KNN
$knn = new KNearestNeighbors();

// 5. Entraîner le modèle
$knn->train($donnees, $labels);

// 6. Faire une prédiction pour le prochain lancer
$nouvelleFrequencePile = $nombrePile / $total;
$nouvelleFrequenceFace = $nombreFace / $total;

$prediction = $knn->predict([$nouvelleFrequencePile, $nouvelleFrequenceFace]);

echo "La prédiction pour le prochain lancer est : " . ($prediction === 1 ? 'pile' : 'face') . "\n";

Explications détaillées :

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 ?

Nous créons un tableau $donnees où chaque élément est un couple [frequencePile, frequenceFace] calculé à partir de l’historique précédent.

$labels contient le vrai résultat qui suit chaque sous-historique. C’est ce que le modèle doit apprendre à prédire.

KNearestNeighbors est choisi pour sa simplicité et son efficacité sur des petits jeux de données.

predict prend les fréquences actuelles comme entrée et prédit la valeur suivante.

Comment enrichir le modèle

Une fois le modèle en place, il est possible de l’améliorer :

Ajouter plus de données : Plus vous avez de lancers, plus le modèle sera précis. Chaque nouveau lancer peut être ajouté à l’historique et recalculé.

Ajouter des features : Par exemple, la suite des trois derniers résultats, ou le nombre de changements consécutifs pile/face.

Essayer d’autres algorithmes : Php-ml propose des forêts aléatoires, des SVM, ou des perceptrons qui peuvent être plus adaptés à des patterns plus complexes.

Normaliser les données : Pour des datasets plus grands, il peut être intéressant de transformer les fréquences pour que toutes les features soient comparables.

Tester le modèle et évaluer ses performances

Après avoir créé notre modèle KNN pour prédire le prochain lancer de pile ou face, il est important de tester sa fiabilité. Même si le pile ou face est aléatoire, tester le modèle nous permet de comprendre comment fonctionne l’apprentissage à partir des fréquences passées.

Voici un exemple simple de test avec calcul de l’exactitude (accuracy) :

<?php

$bonnesPredictions = 0;
$totalTests = count($donnees);

for ($i = 0; $i < $totalTests; $i++) {
    $pred = $knn->predict([$donnees[$i][0], $donnees[$i][1]]);
    if ($pred == $labels[$i]) {
        $bonnesPredictions++;
    }
}

$accuracy = $bonnesPredictions / $totalTests;
echo "Exactitude du modèle : " . ($accuracy * 100) . "%\n";

Explications :

• Nous comparons chaque prédiction du modèle avec le résultat réel.
• $accuracy indique le pourcentage de prédictions correctes.
• Pour un vrai pile ou face, l’exactitude sera proche de 50%, ce qui est normal puisque les lancers sont indépendants.
• Cette étape est cruciale dans le Machine learning, car elle permet de mesurer la performance et d’ajuster le modèle si nécessaire.

Enrichir le modèle avec plus de features

Pour rendre le modèle plus intéressant et exploitable pour des phénomènes non complètement aléatoires, on peut ajouter d’autres features (informations) à chaque observation.

Par exemple, on peut considérer :

• La séquence des trois derniers résultats : [dernier, avant-dernier, troisième-dernier]
• La fréquence glissante sur les 5 derniers lancers
• Le nombre de changements consécutifs (pile → face → pile…)

Chaque feature supplémentaire est une information que le modèle peut utiliser pour détecter des patterns, ce qui est la base du clustering et du Machine learning.

Voici un exemple avec une fréquence glissante sur les 5 derniers lancers :

<?php

$fenetre = 5;
$donneesEnrichies = [];
$labelsEnrichis = [];

for ($i = $fenetre; $i < count($historique); $i++) {
    $sousHistorique = array_slice($historique, $i - $fenetre, $fenetre);
    $nombrePile = count(array_filter($sousHistorique, fn($val) => $val === 1));
    $nombreFace = count(array_filter($sousHistorique, fn($val) => $val === 0));

    $donneesEnrichies[] = [$nombrePile / $fenetre, $nombreFace / $fenetre];
    $labelsEnrichis[] = $historique[$i];
}

$knn->train($donneesEnrichies, $labelsEnrichis);

Explications :

• Nous utilisons une fenêtre glissante pour calculer les fréquences sur les derniers lancers.
• Cela permet au modèle de détecter des variations locales plutôt que de se baser uniquement sur l’historique complet.
• Cette technique est très utilisée dans le Machine learning pour transformer des données temporelles en features exploitables.

Le lien avec le clustering

Dans le Machine learning, le clustering consiste à regrouper des observations similaires. Ici, chaque lancer ou séquence de lancers peut être représenté comme un point dans un espace défini par ses features (fréquence de pile, fréquence de face, séquence glissante…).

• Si plusieurs séquences ont des caractéristiques proches (par exemple 3 piles et 2 faces sur les 5 derniers lancers), elles seront regroupées dans un cluster.
• Ensuite, on peut analyser quel est le résultat le plus probable pour chaque cluster.
• Même si le pile ou face est aléatoire, cette méthode est très utile pour des données où des patterns existent, comme les comportements utilisateurs, ventes, ou événements répétitifs.

Les fréquences passées sont des features de clustering. Elles permettent de transformer un historique en données numériques exploitables pour tout algorithme de Machine learning, même simple comme KNN, ou plus complexe comme les forêts aléatoires et SVM.

Nourrir et enrichir le modèle avec de nouvelles données

Pour que le modèle devienne plus performant sur des phénomènes réels (non aléatoires), il est crucial de l’alimenter régulièrement avec de nouvelles données.

• Chaque nouvel événement est ajouté à l’historique.
• Les features (fréquences, séquences, changements) sont recalculées.
• Le modèle peut être réentraîné périodiquement pour s’adapter aux nouvelles tendances.

En PHP, cela peut se faire simplement en stockant l’historique dans un fichier ou une base de données, et en recalculant les features à chaque nouveau lancer ou événement.

Exemple pratique : ajouter de nouvelles données

<?php

// Ajouter un nouveau lancer
$nouveauLancer = rand(0, 1); // pile ou face aléatoire
$historique[] = $nouveauLancer;

// Recalculer les features avec la fenêtre glissante
$sousHistorique = array_slice($historique, -$fenetre);
$nombrePile = count(array_filter($sousHistorique, fn($val) => $val === 1));
$nombreFace = count(array_filter($sousHistorique, fn($val) => $val === 0));

$donneeNouvelle = [$nombrePile / $fenetre, $nombreFace / $fenetre];
$prediction = $knn->predict($donneeNouvelle);

echo "Nouvelle prédiction : " . ($prediction === 1 ? 'pile' : 'face') . "\n";

Cette méthode illustre parfaitement le cycle du Machine learning : collecte → transformation → entraînement → prédiction → enrichissement.

Nous avons découvert comment utiliser le Machine learning en PHP pour prédire pile ou face à partir des fréquences passées, en utilisant une approche simple avec KNN.

Même si pile ou face est un événement aléatoire, cet exemple est idéal pour comprendre les concepts essentiels du Machine learning : création de features, calcul des fréquences passées, entraînement d’un modèle, test et enrichissement des données.

Vous savez désormais comment :

• Calculer et exploiter les fréquences passées.
• Créer un modèle simple en PHP avec Php-ml.
• Enrichir vos données et utiliser des fenêtres glissantes.
• Comprendre le lien avec le clustering et comment regrouper des observations similaires.
• Mettre en place un processus continu de collecte et réentraînement.

Cet apprentissage vous donne une base solide pour explorer des modèles plus complexes et des données réelles où des patterns existent vraiment. En utilisant les fréquences passées comme feature, vous pouvez appliquer ces techniques à des situations variées, comme l’analyse des comportements utilisateurs, la prévision de ventes, ou l’optimisation de contenus web.

Le plus important est de comprendre le principe de transformation des données en features exploitables, car c’est là que réside la puissance du Machine learning et du clustering. Avec ce socle, vous pourrez progressivement passer à des modèles plus avancés, et enrichir vos prédictions avec des algorithmes plus sophistiqués.

Chapitre 7 : Support Vector Machine →

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr