🔴🟡 Puissance 4 — IA & Machine Learning

Implémentation complète du Puissance 4 sur grille 9×9, avec interface web, GUI desktop, IA Minimax bitboard et réseau neuronal entraîné sur des parties réelles.

---

Table des matières

• Aperçu
• Architecture du projet
• Modes de jeu
• Intelligence Artificielle
• Pipeline de données
• Modèle neuronal
• Installation
• Lancement
• Structure des fichiers
• Base de données

---

Aperçu

Ce projet est une implémentation avancée du Puissance 4 avec deux interfaces (web et desktop), deux moteurs d'IA distincts, et un pipeline complet de collecte → entraînement → inférence.

La grille par défaut est 9×9 (configurable de 4×4 à 30×30). Les parties peuvent être jouées contre l'IA, regardées en replay, ou générées automatiquement pour alimenter le dataset d'entraînement.

---

Architecture du projet

┌─────────────────────────────────────────────────────┐
│                    Interfaces                       │
│   Web (FastAPI + HTML/CSS/JS)   Desktop (Tkinter)   │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│                   Moteur de jeu                     │
│          core.py  ·  controller.py                  │
└──────────┬───────────────────────────┬──────────────┘
           │                           │
┌──────────▼──────────┐   ┌────────────▼─────────────┐
│    IA Minimax       │   │     IA Neuronale          │
│  ai_engine.py       │   │   neural_ai.py            │
│  (bitboard + TT)    │   │   (ResNet PyTorch)        │
└─────────────────────┘   └──────────────────────────┘
                                       ▲
┌──────────────────────────────────────┴──────────────┐
│                Pipeline de données                  │
│  scrape.py → import_csv_to_db.py → train_model.py  │
└─────────────────────────────────────────────────────┘

---

Modes de jeu

Mode	Description
Humain vs Humain	Deux joueurs sur le même écran
Humain vs IA Minimax	Contre le moteur alpha-bêta (profondeur configurable)
Humain vs IA Neuronale	Contre le réseau ResNet entraîné sur parties BGA
IA vs IA	Génération automatique de parties pour le dataset
Replay	Visualisation des parties enregistrées coup par coup

---

Intelligence Artificielle

Minimax Bitboard (ai_engine.py)

Moteur alpha-bêta optimisé v3 avec :

• Représentation bitboard — les plateaux Rouge/Jaune sont encodés en entiers Python, rendant la détection de victoire et l'évaluation très rapides
• Table de transposition — mémoïsation des positions déjà évaluées (jusqu'à 2 millions d'entrées)
• Iterative deepening avec limite de temps (2 secondes par coup)
• Aspiration windows — réduction de la fenêtre alpha-bêta pour couper plus tôt
• Ordre des coups — priorité aux colonnes centrales pour une meilleure coupure
• Heuristique — comptage de menaces fusionné en un seul parcours, bonus de position centrale

# Exemple d'utilisation
from ai_engine import ai_choose_column_from_game
col = ai_choose_column_from_game(game, color="R", depth=6)

IA Neuronale (neural_ai.py)

Réseau de type AlphaZero-lite, entraîné sur des parties humaines récupérées sur BoardGameArena :

• Tronc : 6 blocs résiduels (ResNet), 128 filtres, convolutions 3×3
• Tête policy : distribution de probabilité sur les colonnes jouables
• Tête value : estimation de l'avantage de la position ([-1, +1])
• Entrée : 3 canaux — pions Rouge, pions Jaune, tour à jouer

---

Pipeline de données

BoardGameArena
      │
      ▼
  scrape.py          ← Selenium, scrape les parties 9×9 terminées
      │
      ▼
bga_import.py        ← Parse et normalise les séquences de coups
      │
      ▼
import_csv_to_db.py  ← Insère en base PostgreSQL (déduplication)
      │
      ▼
export_dataset.py    ← Génère dataset.csv pour l'entraînement
      │
      ▼
train_model.py       ← Entraîne le ResNet, sauvegarde .pt + _info.json
      │
      ▼
neural_ai.py         ← Charge le modèle pour les inférences en jeu

Le dataset actuel contient ~53 000 parties avec leurs métadonnées (source, confiance, grille, résultat).

---

Modèle neuronal

Résultats après 15 époques d'entraînement sur le dataset BGA :

Époque	Précision train	Précision val	Loss val
1	63.96%	67.59%	1.305
5	73.43%	72.33%	1.084
10	76.50%	74.04%	1.014
15	79.00%	75.00%	0.987

Architecture : ResNet(rows=9, cols=9, in_ch=3, filters=128, blocks=6) — 1 809 196 paramètres

# Entraîner le modèle
python train_model.py --csv dataset.csv --epochs 50 --filters 128

# Filtrer par niveau de confiance (3 = parties humaines BGA uniquement)
python train_model.py --csv dataset.csv --min_confiance 3

---

Installation

Prérequis : Python 3.10+, PostgreSQL (optionnel)

git clone https://github.com/naitkaci-anis/connect4.git
cd connect4
pip install -r requirements.txt

Dépendances principales :

Paquet	Usage
fastapi + uvicorn	Serveur web
torch	Entraînement et inférence neuronale
selenium	Scraping BoardGameArena
psycopg2	Connexion PostgreSQL
tkinter	Interface desktop (stdlib)

---

Lancement

Interface Web

uvicorn server:app --reload
# → http://localhost:8000

Interface Desktop (Tkinter)

python main.py

Générer des parties IA vs IA (pour le dataset)

python minimax_balanced.py   # Rouge depth 6 vs Jaune depth 5
python minimax_gamebot.py    # Variante bot vs bot

Configurer la grille

Modifier config.json (généré automatiquement au premier lancement) :

{
  "rows": 9,
  "cols": 9,
  "starting_color": "R",
  "cell_size": 64
}

---

Structure des fichiers

connect4/
├── core.py                  # Moteur de jeu : plateau, règles, coups
├── controller.py            # Logique de partie, gestion des tours
├── ai_engine.py             # IA Minimax bitboard (v3)
├── neural_ai.py             # Inférence ResNet
├── train_model.py           # Entraînement PyTorch
├── server.py                # API FastAPI + routes web
├── index.html               # Interface web
├── app.js                   # Logique front-end
├── styles.css               # Styles
├── main.py                  # Point d'entrée desktop (Tkinter)
├── view_tk.py               # Vue Tkinter
├── scrape.py                # Scraping BGA (Selenium)
├── bga_import.py            # Import parties BGA
├── import_csv_to_db.py      # Insertion CSV → PostgreSQL
├── export_dataset.py        # Export dataset pour entraînement
├── minimax_balanced.py      # Génération parties IA vs IA
├── db.py                    # Couche d'accès PostgreSQL
├── schema.sql               # Schéma de la base de données
├── config.json              # Configuration de la grille
├── connect4_model_info.json # Métriques du modèle entraîné
└── dataset.csv              # Dataset d'entraînement (~45k parties)

---

Base de données

Schéma PostgreSQL en deux tables :

games — une ligne par partie

• id, rows, cols, starting_color, status, winner
• canonical_key — clé de déduplication (symétrie gauche/droite)
• confiance — niveau de qualité (0 = bot interne, 3 = humain BGA)

moves — une ligne par coup

• game_id, ply (numéro du coup), col, row, color
• Clé étrangère vers games avec suppression en cascade

# Initialiser la base
psql -U postgres -f schema.sql

# Importer un CSV de parties
python import_csv_to_db.py --csv data.csv

---

Licence

MIT