Script | Prédire ses décisions au poker | Machine Learning PHP

Dans le monde du poker, chaque décision compte. Que vous soyez un joueur débutant ou expérimenté, savoir quand miser, suivre ou se coucher peut faire la différence entre gagner ou perdre une partie. Aujourd’hui, la technologie peut vous aider à améliorer vos choix grâce au Machine Learning en PHP. Ce tutoriel vous explique comment créer un outil simple en PHP capable de prédire la meilleure décision à prendre au poker en fonction des données de jeu passées. N

ous allons aborder le fonctionnement, l’installation, l’utilisation, et la logique derrière chaque étape, de manière claire et accessible pour tous.

Le code présenté ici combine PHP, JavaScript et la bibliothèque PHP-ML pour apprendre à partir de vos propres parties. Vous pourrez saisir vos actions et leurs résultats pour entraîner le modèle, puis obtenir des recommandations personnalisées pour vos futures décisions. L’objectif est de comprendre non seulement comment utiliser cet outil, mais aussi pourquoi chaque étape est importante.

Retrouvez l’ensemble de code sur Github.

À quoi sert ce code ?

Cet outil est un assistant intelligent pour le poker. Il a deux fonctions principales : enregistrer vos données de jeu et prédire vos décisions. Chaque fois que vous jouez, vous pouvez indiquer la force de votre main, le montant du pot, la position à la table, le nombre de joueurs, et la mise de vos adversaires. Vous indiquez également la décision que vous avez prise et le résultat final de la main. Le code prend toutes ces informations pour apprendre vos habitudes et identifier des tendances.

L’idée derrière le Machine Learning appliqué au poker est simple : plus vous fournissez de données, plus le modèle devient précis. Avec suffisamment d’informations, il peut analyser la situation actuelle et suggérer une action optimale comme suivre, relancer ou se coucher. Cela permet d’avoir un assistant intelligent directement accessible depuis votre navigateur, capable de vous guider sans remplacer votre jugement.

<?php
// ================================================================
//  poker_ml.php
//  Script d’apprentissage automatique en PHP appliqué au poker.
//  Nécessite l’installation de la librairie PHP-ML : 
//  -> composer require php-ai/php-ml
// ================================================================

// Chargement automatique des classes PHP-ML
require 'vendor/autoload.php';

// Importation des classes nécessaires depuis PHP-ML
use Phpml\Classification\KNearestNeighbors;
use Phpml\ModelManager;
use Phpml\Metric\Accuracy;

// Définition des fichiers de stockage des données et du modèle
$dataFile = 'poker_data.json';     // Contient l’historique des parties
$modelFile = 'poker_model.model';  // Contient le modèle entraîné

// Chargement du jeu de données existant (ou initialisation vide)
$data = file_exists($dataFile) ? json_decode(file_get_contents($dataFile), true) : [];

// ================================================================
// --- SECTION 1 : ENREGISTREMENT DES DONNÉES + RÉENTRAÎNEMENT ---
// ================================================================
if (isset($_POST['save'])) {

    // --- Création d’une nouvelle entrée à partir du formulaire ---
    $entry = [
        'main' => floatval($_POST['main']),       // Force de la main (0 à 1)
        'mise' => floatval($_POST['mise']),       // Montant de la mise adverse
        'pos' => intval($_POST['pos']),           // Position du joueur à la table
        'joueurs' => intval($_POST['joueurs']),   // Nombre de joueurs en jeu
        'pot' => floatval($_POST['pot']),         // Montant total du pot
        'stack' => floatval($_POST['stack']),     // Votre tapis (stack)
        'tour' => $_POST['tour'],                 // Phase du jeu : préflop, flop, turn, river
        'decision' => $_POST['decision'],         // Décision prise (call, fold, raise)
        'resultat' => floatval($_POST['resultat'])// Résultat final (+ ou - gain)
    ];

    // Ajout de l’entrée au tableau des données
    $data[] = $entry;

    // Limitation du fichier à 500 entrées pour éviter une surcharge
    if (count($data) > 500) array_shift($data);

    // Sauvegarde du nouveau jeu de données dans poker_data.json
    file_put_contents($dataFile, json_encode($data));

    // ------------------------------------------------------------
    // --- Entraînement automatique du modèle après chaque ajout ---
    // ------------------------------------------------------------
    $accuracy = 0;

    // On ne réentraîne que si on possède un minimum de données
    if (count($data) > 20) {

        // Création des échantillons (variables d’entrée)
        $samples = array_map(fn($d) => [
            $d['main'], $d['mise'], $d['pos'], $d['joueurs'], $d['pot'], $d['stack'],
            // Conversion du tour de jeu en valeur numérique
            $d['tour']=='flop'?1:($d['tour']=='turn'?2:3)
        ], $data);

        // Création des étiquettes (résultats attendus : décisions)
        $labels = array_map(fn($d) => $d['decision'], $data);

        // Division du jeu de données : 80% entraînement / 20% test
        $split = intval(count($samples) * 0.8);
        $trainSamples = array_slice($samples, 0, $split);
        $trainLabels  = array_slice($labels, 0, $split);
        $testSamples  = array_slice($samples, $split);
        $testLabels   = array_slice($labels, $split);

        // Création et entraînement du modèle K-Nearest Neighbors
        $model = new KNearestNeighbors();
        $model->train($trainSamples, $trainLabels);

        // Prédictions sur les données de test
        $predicted = [];
        foreach ($testSamples as $s) $predicted[] = $model->predict($s);

        // Calcul de la précision du modèle
        $accuracy = count($predicted) > 0 ? round(Accuracy::score($testLabels, $predicted) * 100, 2) : 0;

        // Sauvegarde du modèle entraîné sur disque
        (new ModelManager())->saveToFile($model, $modelFile);
    }

    // Envoi de la précision au navigateur (affichée en JS)
    echo $accuracy;
    exit;
}

// ================================================================
// --- SECTION 2 : PRÉDICTION DE DÉCISION SELON LES DONNÉES ---
// ================================================================
if (isset($_POST['predict'])) {

    // Vérification du volume de données avant prédiction
    if (count($data) < 10) { 
        echo "Pas assez de données"; 
        exit; 
    }

    // Extraction des échantillons et étiquettes
    $samples = array_map(fn($d) => [
        $d['main'], $d['mise'], $d['pos'], $d['joueurs'], $d['pot'], $d['stack'],
        $d['tour']=='flop'?1:($d['tour']=='turn'?2:3)
    ], $data);
    $labels = array_map(fn($d) => $d['decision'], $data);

    // Entraînement du modèle sur toutes les données disponibles
    $model = new KNearestNeighbors();
    $model->train($samples, $labels);

    // Conversion des données utilisateur en entrée pour la prédiction
    $input = [
        floatval($_POST['main']),
        floatval($_POST['mise']),
        intval($_POST['pos']),
        intval($_POST['joueurs']),
        floatval($_POST['pot']),
        floatval($_POST['stack']),
        $_POST['tour']=='flop'?1:($_POST['tour']=='turn'?2:3)
    ];

    // Prédiction de la décision la plus probable
    $prediction = $model->predict($input);

    // Envoi du résultat au navigateur
    echo $prediction;
    exit;
}
?>

<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>AI Poker Decision</title>

<!-- Importation de jQuery et Chart.js -->
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>

<!-- Feuille de style (version sombre, moderne et compatible Safari) -->
<style>
/* === Structure générale === */
body {
    font-family: 'Segoe UI', Roboto, Arial, sans-serif;
    margin: 40px;
    background: #1e1e1e;
    color: #f1f1f1;
    line-height: 1.6;
}

/* === Titres === */
h1, h2 {
    text-align: center;
    margin-bottom: 25px;
}
h1 {
    color: #4caf50;
}
h2 {
    color: #9cdcfe;
}

/* === Formulaire principal === */
form {
    display: grid;
    grid-template-columns: repeat(2, 1fr);
    gap: 12px 20px;
    max-width: 650px;
    margin: 0 auto 30px auto;
    padding: 25px;
    background: #2a2a2a;
    border-radius: 12px;
    box-shadow: 0 4px 12px rgba(0,0,0,0.3);
}

/* === Champs de saisie généraux === */
input, select, button {
    padding: 10px;
    border-radius: 6px;
    border: 1px solid #444;
    background: #333;
    color: #f9f9f9;
    font-size: 0.95em;
    transition: all 0.2s ease-in-out;
}

/* === Effet focus === */
input:focus, select:focus {
    outline: none;
    border-color: #4caf50;
    background: #2f2f2f;
}

/* === Sélecteurs personnalisés === */
select {
    /* Retirer le style natif des navigateurs */
    -webkit-appearance: none;
    -moz-appearance: none;
    appearance: none;

    /* Style moderne */
    background-color: #333;
    border: 1px solid #555;
    border-radius: 6px;
    color: #fff;
    padding: 10px 35px 10px 12px;
    font-size: 0.95em;
    cursor: pointer;

    /* Ajouter une flèche personnalisée */
    background-image: linear-gradient(45deg, transparent 50%, #4caf50 50%),
                      linear-gradient(135deg, #4caf50 50%, transparent 50%);
    background-position: calc(100% - 18px) center, calc(100% - 13px) center;
    background-size: 5px 5px, 5px 5px;
    background-repeat: no-repeat;
}

/* Flèche changée au survol pour effet dynamique */
select:hover {
    border-color: #4caf50;
    background-image: linear-gradient(45deg, transparent 50%, #81c784 50%),
                      linear-gradient(135deg, #81c784 50%, transparent 50%);
}

/* === Boutons === */
button {
    background: #4caf50;
    color: #fff;
    font-weight: bold;
    border: none;
    cursor: pointer;
    flex: 1;
    transition: background 0.2s;
}
button:hover {
    background: #45a049;
}

/* === Bloc de boutons === */
form div[style*="grid-column"] {
    grid-column: 1 / 3;
    display: flex;
    justify-content: center;
    gap: 15px;
    margin-top: 10px;
}

/* === Zone de résultats === */
#result, #accuracy {
    text-align: center;
    margin-top: 15px;
}
#result {
    font-size: 1.4em;
    color: #ffb74d;
}
#accuracy {
    font-size: 1.2em;
    color: #00e676;
}

/* === Section statistiques === */
canvas {
    background: #fff;
    border-radius: 12px;
    padding: 15px;
    margin: 20px auto;
    display: block;
    max-width: 600px;
    box-shadow: 0 2px 8px rgba(0,0,0,0.25);
}
</style>

</head>
<body>
<h1>Décision Poker (Machine Learning PHP)</h1>

<!-- ============================================================
     Formulaire principal permettant de saisir les données de jeu
     ============================================================ -->
<form id="pokerForm">
    <input type="number" name="main" placeholder="Force de la main (0-1)" step="0.01" required>
    <input type="number" name="mise" placeholder="Mise adverse" step="0.01" required>
    <input type="number" name="pos" placeholder="Position (1-9)" required>
    <input type="number" name="joueurs" placeholder="Nb joueurs" required>
    <input type="number" name="pot" placeholder="Pot actuel" step="0.01" required>
    <input type="number" name="stack" placeholder="Mon Stack" step="0.01" required>

    <!-- Sélecteur du tour de jeu -->
    <select name="tour">
        <option value="preflop">Pré-flop</option>
        <option value="flop">Flop</option>
        <option value="turn">Turn</option>
        <option value="river">River</option>
    </select>

    <!-- Sélecteur de la décision prise -->
    <select name="decision">
        <option value="call">Call</option>
        <option value="fold">Fold</option>
        <option value="raise">Raise</option>
    </select>

    <!-- Champ pour entrer le résultat final -->
    <input name="resultat" placeholder="Résultat (+/- gain)">

    <!-- Boutons d’action -->
    <div style="grid-column:1/3;display:flex;gap:10px;">
        <button type="button" id="predictBtn">Prédire</button>
        <button type="button" id="saveBtn">Enregistrer</button>
    </div>
</form>

<!-- Zones de retour d’information -->
<div id="result"></div>
<div id="accuracy"></div>

<!-- ============================================================
     Graphiques statistiques : fréquence et rentabilité
     ============================================================ -->
<h2>Statistiques</h2>
<canvas id="chart1" width="400" height="200"></canvas>
<canvas id="chart2" width="400" height="200"></canvas>

<!-- ============================================================
     Script JavaScript : communication AJAX + graphiques
     ============================================================ -->
<script>
// Fonction utilitaire : récupère toutes les données du formulaire
function getFormData() {
    return Object.fromEntries(new FormData($("#pokerForm")[0]).entries());
}

// --- Bouton "Prédire" : envoi des données pour obtenir une décision AI ---
$("#predictBtn").on("click",()=>{
    $.post("poker_ml.php",{predict:1,...getFormData()},res=>{
        $("#result").text("Décision suggérée : "+res);
        $("input[name='decision']").val(res); // Remplir automatiquement la décision
    });
});

// --- Bouton "Enregistrer" : stocke les données + réentraîne le modèle ---
$("#saveBtn").on("click",()=>{
    $.post("poker_ml.php",{save:1,...getFormData()},acc=>{
        $("#accuracy").text("Précision actuelle du modèle : "+acc+"%");
        $("#result").text("Données enregistrées ✅");
        $("#pokerForm")[0].reset(); // Réinitialisation du formulaire
        updateCharts();              // Mise à jour des statistiques
    });
});

// --- Fonction de mise à jour des graphiques ---
function updateCharts(){
    fetch('poker_data.json').then(r=>r.json()).then(d=>{
        if(!d || !d.length) return;

        let actions={}, gains={};
        d.forEach(x=>{
            actions[x.decision]=(actions[x.decision]||0)+1;     // Comptage des décisions
            gains[x.decision]=(gains[x.decision]||0)+x.resultat; // Somme des résultats
        });

        // Premier graphique : fréquence des décisions
        new Chart(chart1,{
            type:'bar',
            data:{
                labels:Object.keys(actions),
                datasets:[{label:'Fréquence décisions',data:Object.values(actions)}]
            }
        });

        // Deuxième graphique : rentabilité totale par type de décision
        new Chart(chart2,{
            type:'bar',
            data:{
                labels:Object.keys(gains),
                datasets:[{label:'Rentabilité totale',data:Object.values(gains)}]
            }
        });
    });
}

// Chargement initial des graphiques au démarrage
updateCharts();
</script>
</body>
</html>

Comment installer et utiliser cet outil

Prérequis

Pour utiliser cet outil, vous devez disposer d’un serveur local ou distant capable d’exécuter du PHP 7 ou supérieur. Vous aurez également besoin de Composer, un gestionnaire de dépendances PHP, pour installer la librairie PHP-ML. Cette librairie contient tous les outils nécessaires pour le Machine Learning, comme les algorithmes de classification et la gestion des modèles.

Installation pas à pas

La première étape consiste à créer un dossier pour votre projet, par exemple poker_ml. Ensuite, placez-y le fichier PHP principal et créez un sous-dossier vendor qui sera géré par Composer. Depuis votre terminal, rendez-vous dans le dossier du projet et tapez la commande suivante :

composer require php-ai/php-ml

Cette commande télécharge et installe la librairie PHP-ML, ainsi que toutes ses dépendances, dans le dossier vendor. C’est cette librairie qui permettra de créer et d’entraîner le modèle capable de prédire les décisions de poker.

Ensuite, il vous faudra créer un fichier de données poker_data.json. Ce fichier servira à stocker toutes vos parties et leurs informations. Vous pouvez le créer vide au départ et le remplir automatiquement grâce au formulaire de l’outil.

Lancement et utilisation

Une fois tout installé, ouvrez votre navigateur et rendez-vous sur la page PHP de l’outil. Vous verrez un formulaire clair avec plusieurs champs à remplir : la force de votre main, le montant de la mise adverse, votre position, le nombre de joueurs en jeu, le pot actuel, votre stack, le tour de jeu, la décision prise et le résultat final.

Pour enregistrer vos données, il suffit de remplir le formulaire et de cliquer sur le bouton « Enregistrer ». Le code va ajouter vos informations dans le fichier JSON et réentraîner automatiquement le modèle si suffisamment de données sont disponibles. Cela permet au modèle de devenir plus précis à mesure que vous jouez et enregistrez vos parties.

Pour obtenir une prédiction, vous pouvez remplir les champs avec la situation actuelle et cliquer sur « Prédire ». L’outil vous renverra la décision la plus probable selon les données que vous avez fournies, et remplira automatiquement la décision dans le formulaire pour faciliter l’enregistrement de la main après le coup.

Principes de fonctionnement du code

Collecte des données

Le cœur de l’outil repose sur la collecte des informations de vos parties. Chaque action que vous enregistrez est stockée dans un format structuré, avec des valeurs numériques pour la plupart des paramètres. Cela inclut la force de votre main, la mise adverse, le pot, votre stack, votre position, le nombre de joueurs et le tour de jeu. Ces données sont essentielles car le Machine Learning ne peut apprendre que sur des informations précises et quantifiables.

Conversion des données pour le modèle

Certaines informations, comme le tour de jeu, sont textuelles (pré-flop, flop, turn, river). Le code les convertit en valeurs numériques afin que le modèle puisse les traiter. Par exemple, le flop est codé par 1, le turn par 2, et la river par 3. Cette conversion est importante car les algorithmes de Machine Learning travaillent mieux avec des nombres que des textes.

Entraînement du modèle

L’outil utilise un algorithme appelé K-Nearest Neighbors (KNN), un des plus simples pour la classification. Le principe est de regarder les parties précédentes les plus proches de la situation actuelle et de prédire la décision en fonction des tendances observées. Plus vous fournissez de données, plus le modèle peut identifier des patterns et fournir des suggestions fiables.

Après chaque enregistrement de partie, le modèle peut être réentraîné automatiquement. Il divise les données en deux parties : un ensemble d’entraînement et un ensemble de test. L’ensemble d’entraînement sert à apprendre les tendances, tandis que l’ensemble de test permet de vérifier la précision des prédictions. Le code calcule ensuite un pourcentage de précision que vous pouvez visualiser directement sur la page web.

Prédiction des décisions

Lorsqu’une prédiction est demandée, le code prend les informations actuelles de la partie et les compare à toutes les données précédemment enregistrées. Le modèle KNN examine les parties les plus proches et renvoie la décision la plus probable. C’est ainsi que vous obtenez une suggestion personnalisée et directement exploitable pour votre main en cours.

Interface et formulaire : comment saisir vos parties

L’interface de l’outil a été conçue pour être simple, moderne et intuitive. Elle permet à tout joueur de poker, débutant ou confirmé, de saisir facilement les informations de chaque main et d’obtenir une assistance grâce au Machine Learning.

Le formulaire principal contient plusieurs champs. Chaque champ correspond à un paramètre clé de la partie de poker. Tout d’abord, vous avez la force de votre main, qui est une valeur comprise entre 0 et 1. Cette valeur reflète la puissance de vos cartes et est essentielle pour déterminer la décision la plus adaptée. Ensuite, le formulaire demande la mise de l’adversaire et le pot actuel, afin d’évaluer le risque et la rentabilité de votre action.

Le formulaire inclut également des informations sur la position à la table et le nombre de joueurs en jeu. La position influence fortement votre stratégie, car être en début ou en fin de parole change la manière de jouer. Le nombre de joueurs permet au modèle de contextualiser la situation, car certaines décisions dépendent du nombre d’adversaires encore en course.

Enfin, le formulaire propose un champ pour le stack, c’est-à-dire la taille de votre tapis, un sélecteur pour le tour de jeu(pré-flop, flop, turn, river), la décision que vous avez prise (call, fold ou raise), et le résultat final de la main. Tous ces paramètres sont stockés de manière structurée et sont utilisés à la fois pour entraîner le modèle et pour générer des prédictions précises.

Interaction avec le formulaire : prédiction et enregistrement

Deux boutons principaux permettent d’interagir avec l’outil : Prédire et Enregistrer.

Le bouton Prédire envoie les données actuelles à PHP via une requête AJAX. Le code récupère ces informations, les transforme en format numérique si nécessaire, et utilise le modèle KNN pour suggérer la décision la plus adaptée. Cette approche en temps réel permet d’obtenir immédiatement une recommandation avant de prendre votre action. La décision suggérée est affichée directement sur la page et remplit automatiquement le champ correspondant dans le formulaire. Cela simplifie la tâche de l’utilisateur et facilite l’enregistrement de la partie ensuite.

Le bouton Enregistrer permet de sauvegarder vos données dans le fichier JSON et de réentraîner automatiquement le modèle si suffisamment de parties ont été enregistrées. Cette étape est cruciale : plus le modèle a de données, plus ses prédictions deviennent fiables. Le code limite le fichier de données à 500 entrées pour éviter un ralentissement, en supprimant les plus anciennes parties si nécessaire. Après l’enregistrement, le code calcule également la précision actuelle du modèle et l’affiche pour que vous puissiez suivre l’évolution de la performance de votre assistant.

Visualisation des statistiques : fréquence et rentabilité

Un des aspects intéressants de cet outil est la visualisation des statistiques. Deux graphiques sont générés automatiquement pour vous aider à analyser vos habitudes et vos performances. Le premier graphique montre la fréquence de vos décisions. Vous pouvez ainsi voir combien de fois vous avez suivi, relancé ou vous êtes couché. Cette visualisation est utile pour identifier vos tendances et vos biais, par exemple si vous avez tendance à suivre trop souvent ou à relancer trop rarement.

Le deuxième graphique représente la rentabilité totale par type de décision. Ici, le code additionne le résultat de toutes les mains pour chaque décision et l’affiche sous forme de graphique. Cela permet de visualiser rapidement quelles actions vous rapportent le plus ou le moins. Ces informations sont essentielles pour affiner votre stratégie et comprendre l’impact de vos choix.

La mise à jour des graphiques se fait automatiquement à chaque enregistrement, grâce à un code JavaScript intégré qui récupère les données JSON et calcule les totaux et les fréquences. Les graphiques sont présentés dans un style moderne et lisible, avec des couleurs claires sur un fond sombre, pour une lecture agréable et intuitive.

Le rôle du JavaScript et de l’AJAX

Le JavaScript joue un rôle central dans l’interactivité de l’outil. Il permet d’envoyer les informations du formulaire vers le serveur sans recharger la page, grâce à l’utilisation d’AJAX. Cette technique rend l’expérience utilisateur fluide et réactive.

Lorsque vous cliquez sur Prédire, le code JavaScript récupère toutes les valeurs du formulaire, les envoie au serveur et affiche la réponse en quelques millisecondes. Lorsque vous cliquez sur Enregistrer, les mêmes valeurs sont envoyées pour être stockées, et le modèle est réentraîné automatiquement si nécessaire.

Le JavaScript gère également la mise à jour des graphiques en temps réel. Après chaque enregistrement, il récupère toutes les données de jeu, calcule les statistiques et les envoie à Chart.js, une bibliothèque qui se charge de générer des graphiques dynamiques. Cela offre un retour visuel immédiat sur votre style de jeu et l’efficacité de vos décisions.

Précision et fiabilité du modèle

La précision du modèle est un élément clé pour mesurer son utilité. Le code calcule un pourcentage de précision basé sur la comparaison entre les décisions prédites et celles réellement prises dans les parties de test. Plus vous enregistrez de parties, plus ce pourcentage devient significatif.

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 ?

Le modèle utilisé, K-Nearest Neighbors, fonctionne sur le principe de la proximité. Pour prédire la décision d’une situation actuelle, il regarde les parties les plus proches dans l’espace des paramètres (main, mise, stack, pot, position, nombre de joueurs, tour de jeu) et choisit la décision la plus fréquente parmi ces parties similaires. Ce principe simple mais efficace permet au modèle de fournir des suggestions pertinentes, même si les données initiales sont limitées.

Comprendre le fonctionnement interne côté PHP

Le PHP est le cœur de cet outil. Il gère à la fois la collecte des données, l’entraînement du modèle, et la prédiction des décisions. Son rôle est de transformer les informations que vous saisissez en données exploitables pour le Machine Learning, puis de fournir des résultats précis et fiables.

Structure générale du code PHP

Le code se divise en deux sections principales. La première est dédiée à l’enregistrement des données et au réentraînement du modèle, tandis que la deuxième s’occupe de la prédiction des décisions. Cette séparation claire permet de maintenir le code lisible et d’isoler chaque fonction pour un meilleur contrôle.

1. Enregistrement des données

Lorsque vous cliquez sur « Enregistrer », le code PHP commence par récupérer les informations du formulaire. Chaque paramètre est converti dans le type approprié : les nombres en flottants ou entiers, et le tour de jeu en valeur numérique. Ces conversions sont essentielles pour que le modèle puisse traiter les informations correctement, car le Machine Learning nécessite des données numériques structurées.

Une fois les données préparées, elles sont ajoutées au fichier JSON existant. Si le nombre d’entrées dépasse 500, les plus anciennes sont supprimées pour éviter une surcharge et maintenir le fichier léger. Cette gestion permet de conserver un historique récent et pertinent, tout en assurant des performances optimales.

2. Réentraînement automatique

Après chaque enregistrement, le code vérifie si le nombre de parties enregistrées est suffisant pour entraîner un modèle fiable. Dans ce cas, il divise les données en deux ensembles : un pour l’entraînement et un pour le test. L’ensemble d’entraînement est utilisé pour apprendre les tendances, tandis que l’ensemble de test sert à évaluer la précision du modèle.

Le modèle K-Nearest Neighbors est ensuite créé et entraîné avec les échantillons et les labels extraits des données. Enfin, les prédictions sont comparées aux décisions réelles de l’ensemble de test, et un pourcentage de précision est calculé. Ce chiffre est affiché à l’utilisateur pour qu’il puisse suivre l’évolution de la performance du modèle.

Prédiction des décisions

La deuxième section du code PHP est dédiée à la prédiction. Lorsque vous cliquez sur « Prédire », le code récupère les informations du formulaire, les convertit en format numérique, puis entraîne un modèle KNN sur toutes les données disponibles. L’algorithme compare la situation actuelle aux parties passées et renvoie la décision la plus probable. Cette réponse est envoyée au navigateur et affichée dans le formulaire, ce qui rend le processus interactif et instantané.

Il est important de noter que le modèle ne fait pas de magie. Sa précision dépend entièrement de la qualité et de la quantité des données que vous avez enregistrées. Plus vos parties sont variées et représentatives de situations réelles, plus le modèle pourra fournir des recommandations fiables.

Conseils pour améliorer le modèle

Même si cet outil fonctionne dès son installation, il existe plusieurs moyens d’améliorer ses performances :

1. Enregistrer plus de parties : Un volume important de données permet au modèle d’identifier des tendances plus fines et de prédire plus précisément vos décisions.
2. Normaliser les valeurs : Pour certaines variables, comme la force de la main ou le montant des mises, il peut être utile de normaliser les valeurs afin que le modèle ne soit pas influencé par des échelles trop différentes.
3. Tester d’autres algorithmes : PHP-ML propose plusieurs autres méthodes de classification, comme les arbres de décision ou les forêts aléatoires, qui peuvent offrir de meilleures performances selon vos données.
4. Analyser les graphiques : Les statistiques de fréquence et de rentabilité ne servent pas seulement à visualiser vos habitudes, elles peuvent aussi indiquer quels types de situations nécessitent plus de données ou un ajustement stratégique.

Gestion des fichiers et performances

Le code stocke les données dans un fichier JSON et le modèle dans un fichier séparé. Cette organisation simplifie la gestion et permet de sauvegarder l’état actuel de l’outil sans dépendre d’une base de données complexe. Il est toutefois conseillé de faire des sauvegardes régulières du fichier JSON pour éviter toute perte de données.

La limitation à 500 entrées assure une fluidité du système même après de nombreuses parties. Pour des volumes plus importants, il serait possible d’utiliser une base de données MySQL ou SQLite, ce qui permettrait de gérer des milliers de mains sans perte de performance.

Sécurité et bonnes pratiques

Lorsque vous manipulez des données côté serveur, il est essentiel de valider et de nettoyer les informations reçues pour éviter des erreurs ou des intrusions. Le code convertit les valeurs reçues du formulaire en types appropriés et limite les options possibles pour les sélecteurs (tour de jeu, décision). Cette approche réduit les risques d’injection et garantit que le modèle reçoit uniquement des informations cohérentes.

Il est également conseillé de protéger l’accès aux fichiers JSON et aux modèles afin que seules les personnes autorisées puissent modifier ou consulter les données. Un simple contrôle par mot de passe ou par session peut suffire pour sécuriser l’outil.

Personnalisation et extensions possibles

Le code est conçu de manière modulaire et peut être facilement étendu. Vous pourriez, par exemple, ajouter :

• De nouvelles variables comme la position relative à un adversaire agressif ou la taille de la mise moyenne.
• Des filtres pour analyser uniquement certaines phases du tournoi ou certains types de parties.
• Un historique graphique plus détaillé, avec évolution de la précision du modèle dans le temps.

Ces améliorations permettent de transformer un outil simple en un assistant de poker beaucoup plus puissant et précis.

Optimiser l’utilisation de votre assistant poker

Une fois que votre outil est installé et fonctionnel, l’étape suivante consiste à l’utiliser de manière optimale pour améliorer vos performances au poker. La clé est de combiner l’enregistrement systématique de vos parties avec l’analyse régulière des statistiques.

Enregistrement systématique

Chaque main jouée est une opportunité d’alimenter votre modèle. Même si certaines mains semblent simples ou peu significatives, elles contiennent des informations importantes sur votre comportement et vos tendances. Enregistrer toutes vos parties permet au modèle d’apprendre de manière plus complète et d’identifier des patterns plus précis. Plus vous aurez de données, plus les prédictions seront fiables.

Il est également recommandé de remplir avec soin chaque champ du formulaire. La force de la main, la mise adverse, le pot, votre stack et la position sont des informations essentielles pour que le modèle comprenne le contexte exact de chaque décision. Même de petites erreurs ou omissions peuvent affecter la précision des prédictions.

Utiliser les prédictions intelligemment

L’outil fournit des suggestions basées sur vos données passées et le comportement général observé. Il est important de ne pas suivre aveuglément chaque prédiction. Considérez les recommandations comme un guide supplémentaire pour réfléchir à vos choix, surtout dans des situations complexes ou face à des adversaires imprévisibles.

L’intérêt principal de cet assistant est de vous aider à prendre conscience de vos habitudes et à identifier les décisions les plus rentables dans différentes situations. Par exemple, si le modèle suggère systématiquement de suivre dans une certaine configuration, vous pouvez analyser pourquoi et ajuster votre stratégie si nécessaire.

Analyse des graphiques

Les graphiques de fréquence et de rentabilité sont plus que des éléments visuels. Ils permettent de comprendre vos tendances globales.

Si vous observez que certaines décisions ont une rentabilité faible ou négative malgré une forte fréquence, cela peut indiquer un biais ou une habitude à corriger. Inversement, des décisions moins fréquentes mais très rentables peuvent signaler des opportunités à exploiter davantage.

L’analyse régulière de ces graphiques aide à mieux planifier vos actions futures, à ajuster votre style de jeu et à prendre des décisions plus stratégiques. Au fil du temps, cette approche permet de combiner l’intuition humaine avec la puissance analytique du Machine Learning.

Conseils pour maximiser les performances du modèle

1. Varier les situations : Jouer différents types de parties, avec différents adversaires et positions, enrichit le modèle et améliore sa capacité à généraliser.
2. Réentraîner régulièrement : Chaque nouvel enregistrement augmente la précision du modèle. Plus vous jouez et enregistrez, plus les recommandations deviennent fiables.
3. Observer les résultats : Utilisez les graphiques pour détecter les tendances négatives et ajuster votre style de jeu en conséquence.
4. Tester de nouvelles stratégies : Profitez des prédictions pour essayer des actions différentes et analyser leur rentabilité, ce qui vous permet d’expérimenter sans risque excessif.

Le Machine Learning appliqué au poker est un outil puissant pour améliorer vos décisions, mais il ne remplace pas l’intuition et l’expérience du joueur. L’outil que nous avons présenté permet de saisir vos données de jeu, d’entraîner un modèle intelligent et de visualiser vos résultats de manière claire et pratique.

Grâce à l’enregistrement systématique de vos parties, au réentraînement automatique du modèle et à la visualisation des statistiques, vous disposez d’un assistant capable de vous fournir des recommandations adaptées à votre style de jeu. Les graphiques de fréquence et de rentabilité offrent un retour concret sur vos habitudes et permettent d’identifier les actions les plus efficaces.

En combinant cette approche avec votre expérience personnelle, vous pouvez affiner votre stratégie et prendre des décisions plus réfléchies et rentables. Le principal atout de cet outil est qu’il évolue avec vous : plus vous l’utilisez, plus il devient précis, pertinent et utile.

Ainsi, ce projet n’est pas seulement un script PHP avec du Machine Learning, c’est un véritable compagnon pour tout joueur souhaitant progresser au poker de manière méthodique et éclairée. En exploitant les données, en analysant vos habitudes et en testant vos décisions, vous transformez chaque partie en une opportunité d’apprentissage et d’optimisation.

Avec de la régularité et une utilisation intelligente, ce système peut devenir un atout précieux pour développer vos compétences et maximiser vos gains, tout en rendant l’expérience de jeu plus analytique, stratégique et enrichissante.

Retrouvez l’ensemble de code sur Github.

Chapitre 10 : Script prédiction résultats Ligue 1 →

Alban

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

crea-troyes.fr