L'IA apprend à voir

from PIL import Image
import os

def extraire_features(chemin_image):
    """Retourne (moy_R, moy_G, moy_B) d'une image iris."""
    img = Image.open(chemin_image).convert("RGB")
    pixels = list(img.getdata())
    n = len(pixels)
    moy_r = sum(p[0] for p in pixels) / n
    moy_g = sum(p[1] for p in pixels) / n
    moy_b = sum(p[2] for p in pixels) / n
    return [moy_r, moy_g, moy_b]

# Structure des données : dossier par couleur
# iris_dataset/bleu/    iris_dataset/vert/
# iris_dataset/marron/  iris_dataset/sombre/

X = []  # features : liste de [moy_R, moy_G, moy_B]
y = []  # labels   : liste de couleurs

couleurs = ["bleu", "vert", "marron", "sombre"]
for couleur in couleurs:
    dossier = f"iris_dataset/{couleur}/"
    if not os.path.exists(dossier):
        continue
    for fichier in os.listdir(dossier):
        if fichier.endswith((".jpg", ".png")):
            features = extraire_features(dossier + fichier)
            X.append(features)
            y.append(couleur)

print(f"Dataset : {len(X)} images, {len(set(y))} classes")
print(f"Exemple de features : {X[0]}")

from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Diviser en données d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,       # 20% pour le test
    random_state=42,    # reproductibilité
    stratify=y           # equilibrer les classes
)

print(f"Entraînement : {len(X_train)} iris")
print(f"Test         : {len(X_test)} iris")

# Créer et entraîner le classifieur KNN
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

# Évaluer sur les données de test
y_pred = knn.predict(X_test)
precision = accuracy_score(y_test, y_pred)
print(f"\nPrecision du modele KNN (K=3) : {precision*100:.1f}%")

# Tester avec différentes valeurs de K
print("\nInfluence de K :")
for k in [1, 3, 5, 7, 9]:
    modele_k = KNeighborsClassifier(n_neighbors=k)
    modele_k.fit(X_train, y_train)
    prec_k = accuracy_score(y_test, modele_k.predict(X_test))
    print(f"  K={k} : {prec_k*100:.1f}%")

from sklearn.metrics import confusion_matrix, classification_report

# Matrice de confusion
classes = ["bleu", "vert", "marron", "sombre"]
matrice = confusion_matrix(y_test, y_pred, labels=classes)

print("Matrice de confusion :")
print(f"{'':10s}" + " ".join(f"{c:8s}" for c in classes))
for i, ligne in enumerate(matrice):
    print(f"{classes[i]:10s}" + " ".join(f"{v:8d}" for v in ligne))

# Rapport détaillé par classe
print("\nRapport par couleur :")
print(classification_report(y_test, y_pred, target_names=classes))

# Prédire un nouvel iris inconnu
print("\n--- Test sur un iris inconnu ---")
iris_inconnu = extraire_features("nouvel_iris.png")
prediction = knn.predict([iris_inconnu])[0]
proba = knn.predict_proba([iris_inconnu])[0]
print(f"Couleur predite : {prediction}")
for c, p in zip(knn.classes_, proba):
    barre = "█" * int(p * 20)
    print(f"  {c:8s} {barre:20s} {p*100:.1f}%")

from sklearn.tree import DecisionTreeClassifier, export_text
import matplotlib.pyplot as plt
from sklearn import tree

# Entraîner un arbre de décision
arbre = DecisionTreeClassifier(max_depth=4, random_state=42)
arbre.fit(X_train, y_train)

precision_arbre = accuracy_score(y_test, arbre.predict(X_test))
print(f"Precision arbre de decision : {precision_arbre*100:.1f}%")

# Afficher les règles en texte lisible
regles = export_text(arbre, feature_names=["moy_R", "moy_G", "moy_B"])
print("\nRegles apprises par l'arbre :")
print(regles)

# Visualisation graphique de l'arbre
fig, ax = plt.subplots(figsize=(14, 6))
tree.plot_tree(
    arbre,
    feature_names=["moy_R", "moy_G", "moy_B"],
    class_names=arbre.classes_,
    filled=True,
    rounded=True,
    fontsize=9,
    ax=ax
)
plt.title("Arbre de decision — Classification couleur d'iris")
plt.savefig("arbre_iris.png", dpi=150, bbox_inches="tight")
plt.show()
print("Arbre sauvegarde : arbre_iris.png")