import cv2
import [Link] as plt
import numpy as np
# Définition des chemins des images
image_paths = {
"argileux": [
"C:/Users/usr/Desktop/dataset/argileux/[Link]",
"C:/Users/usr/Desktop/dataset/argileux/[Link]",
"C:/Users/usr/Desktop/dataset/argileux/[Link]",
"C:/Users/usr/Desktop/dataset/argileux/[Link]"
],
"sableux": [
"C:/Users/usr/Desktop/dataset/sableux/[Link]",
"C:/Users/usr/Desktop/dataset/sableux/[Link]",
"C:/Users/usr/Desktop/dataset/sableux/[Link]",
"C:/Users/usr/Desktop/dataset/sableux/[Link]"
],
"limoneux": [
"C:/Users/usr/Desktop/dataset/limoneux/[Link]",
"C:/Users/usr/Desktop/dataset/limoneux/[Link]",
"C:/Users/usr/Desktop/dataset/limoneux/[Link]",
"C:/Users/usr/Desktop/dataset/limoneux/[Link]"
]
}
# Listes pour stocker les images et leurs labels
data = []
labels = []
image_size = (128, 128) # Taille fixe pour homogénéiser les images
# Chargement et redimensionnement des images
for category, paths in image_paths.items():
for img_path in paths:
image = [Link](img_path, cv2.IMREAD_GRAYSCALE) # Chargement en niveaux
de gris
if image is not None:
image = [Link](image, image_size) # Redimensionnement
[Link](image)
[Link](category)
# Conversion en tableau numpy
data = [Link](data)
labels = [Link](labels)
# Affichage de toutes les images
fig, axes = [Link](3, 4, figsize=(12, 9))
for i, ax in enumerate([Link]):
[Link](data[i], cmap='gray')
ax.set_title(labels[i])
[Link]('off')
plt.tight_layout() # Ajuster la mise en page
[Link]()
import cv2
import numpy as np
# Vérification du nombre d'images chargées
print(f"Nombre total d'images chargées : {len(data)}")
print(f"Nombre total de labels : {len(labels)}")
# Vérification des dimensions des images
print(f"Dimensions des images : {data[0].shape}")
# Normalisation des images (conversion en valeurs entre 0 et 1)
data = [Link](data, dtype=np.float32) / 255.0
# Mise en forme des images pour l'apprentissage automatique
X = [Link](len(data), -1) # Transformation des images en vecteurs 1D
y = [Link](labels) # Labels sous forme de tableau numpy
# Vérification finale
print(f"Nouvelle forme des données : {[Link]}") # Doit être (12, 16384) pour
128x128 images
print(f"Labels uniques : {[Link](y)}")
import cv2
import numpy as np
from [Link] import local_binary_pattern
import [Link] as plt
# Paramètres LBP
radius = 1 # Distance des voisins
n_points = 8 * radius # Nombre de voisins autour du pixel central
def extract_lbp_features(image):
"""
Calcule le Local Binary Pattern (LBP) et retourne l'image LBP + l'histogramme
normalisé.
"""
lbp = local_binary_pattern(image, n_points, radius, method="uniform")
# Calcul de l'histogramme LBP
hist, _ = [Link]([Link](), bins=[Link](0, n_points + 3), range=(0,
n_points + 2))
# Normalisation de l'histogramme
hist = [Link]("float")
hist /= ([Link]() + 1e-6) # Éviter la division par zéro
return lbp, hist
# Extraction des caractéristiques LBP pour toutes les images
lbp_images = []
lbp_histograms = []
for img in data:
lbp_img, hist = extract_lbp_features(img)
lbp_images.append(lbp_img)
lbp_histograms.append(hist)
# Conversion en numpy array
lbp_histograms = [Link](lbp_histograms)
# Affichage des images et de leurs LBP
fig, axes = [Link](4, 6, figsize=(15, 10)) # 4 lignes, 6 colonnes
for i in range(len(data)):
# Image originale
axes[i // 3, (i % 3) * 2].imshow(data[i], cmap='gray')
axes[i // 3, (i % 3) * 2].set_title(f"Image {i+1} ({labels[i]})")
axes[i // 3, (i % 3) * 2].axis("off")
# Image LBP
axes[i // 3, (i % 3) * 2 + 1].imshow(lbp_images[i], cmap='gray')
axes[i // 3, (i % 3) * 2 + 1].set_title(f"LBP {i+1}")
axes[i // 3, (i % 3) * 2 + 1].axis("off")
plt.tight_layout()
[Link]()
# Affichage des histogrammes LBP
fig, axes = [Link](3, 4, figsize=(12, 9)) # 3 lignes, 4 colonnes
for i in range(len(data)):
axes[i // 4, i % 4].bar(range(len(lbp_histograms[i])), lbp_histograms[i])
axes[i // 4, i % 4].set_title(f"Histogramme {i+1}")
axes[i // 4, i % 4].set_xlabel("Valeurs LBP")
axes[i // 4, i % 4].set_ylabel("Fréquence")
plt.tight_layout()
[Link]()
from sklearn.model_selection import train_test_split
from [Link] import SVC
from [Link] import LabelEncoder
from [Link] import accuracy_score, confusion_matrix
import seaborn as sns
from [Link] import RandomForestClassifier
# Encodage des labels (conversion texte -> chiffres)
label_encoder = LabelEncoder()
y_encoded = label_encoder.fit_transform(labels)
# Division des données en ensemble d'entraînement (80%) et de test (20%)
X_train, X_test, y_train, y_test = train_test_split(lbp_histograms, y_encoded,
test_size=0.2, random_state=42)
# Création et entraînement du modèle Random Forest
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
# Entraînement du modèle sur les données d'entraînement
rf_model.fit(X_train, y_train)
# Prédiction
y_pred_rf = rf_model.predict(X_test)
# Évaluation du modèle
accuracy_rf= accuracy_score(y_test, y_pred_rf)
print(f"Précision du modèle Random Forest : {accuracy_rf * 100:.2f}%")
# Matrice de confusion
conf_matrix_rf = confusion_matrix(y_test, y_pred_rf)
# Affichage de la matrice de confusion
[Link](figsize=(5, 4))
[Link](conf_matrix_rf, annot=True, fmt="d", cmap="Oranges",
xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_)
[Link]("Prédictions")
[Link]("Vraies classes")
[Link]("Matrice de confusion - Random Forest")
[Link]()
from sklearn.model_selection import train_test_split
from [Link] import SVC
from [Link] import LabelEncoder
from [Link] import accuracy_score, confusion_matrix
import seaborn as sns
from [Link] import RandomForestClassifier
# Création et entraînement du modèle Random Forest
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
# Prédiction
y_pred_rf = rf_model.predict(X_test)
# Évaluation du modèle
accuracy_rf = accuracy_score(y_test, y_pred_rf)
print(f"Précision du modèle Random Forest : {accuracy_rf * 100:.2f}%")
# Matrice de confusion
conf_matrix_rf = confusion_matrix(y_test, y_pred_rf)
# Affichage de la matrice de confusion
[Link](figsize=(5, 4))
[Link](conf_matrix_rf, annot=True, fmt="d", cmap="Oranges",
xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_)
[Link]("Prédictions")
[Link]("Vraies classes")
[Link]("Matrice de confusion - Random Forest")
[Link]()
from [Link] import roc_curve, auc
from [Link] import label_binarize
from itertools import cycle
# Transformation des labels en format one-vs-all (pour ROC multi-classe)
y_test_bin = label_binarize(y_test, classes=[Link](y_encoded))
n_classes = y_test_bin.shape[1]
# Vérifier si le modèle supporte predict_proba()
if hasattr(rf_model, "decision_function"):
y_score = rf_model.decision_function(X_test)
else:
y_score = rf_model.predict_proba(X_test)
# Création de la figure
[Link](figsize=(8, 6))
# Couleurs pour chaque classe
colors = cycle(["blue", "red", "green"])
for i, color in zip(range(n_classes), colors):
fpr, tpr, _ = roc_curve(y_test_bin[:, i], y_score[:, i])
roc_auc = auc(fpr, tpr)
# Tracé de la courbe
[Link](fpr, tpr, color=color, lw=2, label=f"Classe
{label_encoder.classes_[i]} (AUC = {roc_auc:.2f})")
# Diagonale de référence (classifieur aléatoire)
[Link]([0, 1], [0, 1], "k--", lw=2)
# Paramètres du graphique
[Link]([0.0, 1.0])
[Link]([0.0, 1.05])
[Link]("Taux de Faux Positifs (FPR)")
[Link]("Taux de Vrais Positifs (TPR)")
[Link]("Courbe ROC Multi-classe - SVM")
[Link](loc="lower right")
[Link]()
