Système ABS - Simulation par Logique Floue

Projet Calcul Intelligent Travail réalisé par Yosr Barghouti 3IDL2 https://abs-fuzzy-logic.onrender.com// Application web Flask interactive pour simuler un système de Freinage d'Urgence Automatique (AEB) utilisant la logique floue et la méthode d'inférence de Mamdani.

Démonstration rapide de l'application web

Description

Ce projet implémente un contrôleur flou pour un système ABS qui calcule la pression de freinage optimale en fonction de :

Distance à l'obstacle : 0-100 mètres
Vitesse relative du véhicule : 0-100 km/h

Le système utilise 9 règles floues et la méthode d'inférence de Mamdani avec 3 méthodes de défuzzification comparées en temps réel :

Centroïde (COG) - Recommandée pour ce système
Premier Maximum (FOM) - Décision rapide
Milieu de Noyau (MOM) - Compromis

Qu'est-ce que la Logique Floue ?

La logique floue est une approche mathématique permettant de gérer l'incertitude et l'imprécision dans les systèmes de contrôle. Contrairement à la logique binaire (vrai/faux), la logique floue permet des valeurs intermédiaires.

Exemple Concret

En logique classique :

Distance = 35m → "Proche" OU "Moyen" (choix binaire)

En logique floue :

Distance = 35m → "Proche" à 60% ET "Moyen" à 40% (transition graduelle)

Cette capacité à gérer les transitions douces rend la logique floue idéale pour les systèmes de contrôle automobile comme l'ABS, où les décisions doivent être progressives et non brusques.

Pourquoi utiliser la Logique Floue pour l'ABS ?

Décisions progressives : Pas de freinage brutal Gestion de l'incertitude : Capteurs imprécis, conditions variables Règles intuitives : "Si distance proche ET vitesse élevée ALORS pression urgente" Robustesse : Fonctionne dans des conditions variées

Processus d'Inférence de Mamdani

Le système utilise la méthode d'inférence de Mamdani qui se déroule en 5 étapes distinctes. Cette section explique chaque étape en détail avec des visualisations.

Étape 1 : Fuzzification

Objectif : Convertir les valeurs d'entrée nettes (crisp) en degrés d'appartenance aux ensembles flous.

Exemple : Pour Distance = 30m et Vitesse = 60 km/h

# Calcul des degrés d'appartenance pour la Distance
Distance = 30m
μ_Proche(30)   = 0.250  # 25% d'appartenance à "Proche"
μ_Moyen(30)    = 0.333  # 33% d'appartenance à "Moyen"
μ_Lointain(30) = 0.000  # 0% d'appartenance à "Lointain"

# Calcul des degrés d'appartenance pour la Vitesse
Vitesse = 60 km/h
μ_Faible(60)  = 0.000  # 0% d'appartenance à "Faible"
μ_Moyen(60)   = 0.667  # 67% d'appartenance à "Moyen"
μ_Élevé(60)   = 0.333  # 33% d'appartenance à "Élevé"

Code scikit-fuzzy :

import skfuzzy as fuzz
from skfuzzy import control as ctrl

# Définition des univers de discours
distance = ctrl.Antecedent(np.arange(0, 101, 1), 'distance')
velocity = ctrl.Antecedent(np.arange(0, 101, 1), 'velocity')

# Définition des fonctions d'appartenance (triangulaires)
distance['C'] = fuzz.trimf(distance.universe, [0, 0, 40])    # Proche
distance['M'] = fuzz.trimf(distance.universe, [20, 50, 80])  # Moyen
distance['L'] = fuzz.trimf(distance.universe, [60, 100, 100])# Lointain

# Calcul de l'appartenance pour une valeur donnée
distance_value = 30
membership_C = fuzz.interp_membership(distance.universe, distance['C'].mf, distance_value)

Étape 2 : Activation des Règles (Opérateur AND)

Objectif : Calculer le degré d'activation de chaque règle en appliquant l'opérateur AND (min) sur les antécédents.

Formule : α_règle = min(μ_Distance, μ_Vitesse)

Exemple : Règles activées pour Distance = 30m, Vitesse = 60 km/h

# Règle 5: SI Distance = Moyen ET Vitesse = Moyen ALORS Pression = Moyenne
α_R5 = min(μ_Moyen_Distance, μ_Moyen_Vitesse)
α_R5 = min(0.333, 0.667) = 0.333

# Règle 6: SI Distance = Moyen ET Vitesse = Élevé ALORS Pression = Élevée
α_R6 = min(μ_Moyen_Distance, μ_Élevé_Vitesse)
α_R6 = min(0.333, 0.333) = 0.333

# Règle 8: SI Distance = Proche ET Vitesse = Moyen ALORS Pression = Élevée
α_R8 = min(μ_Proche_Distance, μ_Moyen_Vitesse)
α_R8 = min(0.250, 0.667) = 0.250

Code Python :

def activate_rule(distance_membership, velocity_membership):
    """Calcule l'activation d'une règle avec l'opérateur min"""
    return min(distance_membership, velocity_membership)

# Exemple
activation_R5 = activate_rule(0.333, 0.667)  # Retourne 0.333

Étape 3 : Implication (Méthode de Mamdani - min)

Objectif : Tronquer la fonction d'appartenance de la conclusion par le degré d'activation de la règle.

Formule : μ'_conclusion(x) = min(α_règle, μ_conclusion(x))

Exemple : Pour la règle R5 activée à α = 0.333 avec conclusion "Pression Moyenne"

# Fonction d'appartenance originale de "Pression Moyenne"
μ_Moyen_original(x) = trimf(x, [25, 50, 75])

# Fonction tronquée par l'activation
μ'_Moyen(x) = min(0.333, μ_Moyen_original(x))

# Résultat : La fonction est "coupée" à la hauteur 0.333

Code scikit-fuzzy :

def mamdani_implication(activation_level, output_mf):
    """Applique l'implication de Mamdani (min)"""
    return np.minimum(activation_level, output_mf)

# Exemple
original_mf = fuzz.trimf(np.arange(0, 101, 1), [25, 50, 75])
truncated_mf = mamdani_implication(0.333, original_mf)

Étape 4 : Agrégation (Opérateur max)

Objectif : Combiner toutes les fonctions d'appartenance tronquées en une seule fonction globale.

Formule : μ_global(x) = max(μ'_R1(x), μ'_R2(x), ..., μ'_R9(x))

Visualisation : Toutes les fonctions impliquées sont superposées, et l'opérateur max prend la valeur maximale à chaque point.

# Agrégation de 3 règles activées
μ'_R5(x) = min(0.333, μ_Moyen(x))      # Pression Moyenne
μ'_R6(x) = min(0.333, μ_Élevé(x))      # Pression Élevée
μ'_R8(x) = min(0.250, μ_Élevé(x))      # Pression Élevée

# Fonction agrégée
μ_global(x) = max(μ'_R5(x), μ'_R6(x), μ'_R8(x))

Code Python :

def aggregate_rules(implicated_functions):
    """Agrège toutes les fonctions avec l'opérateur max"""
    aggregated = np.zeros_like(implicated_functions[0])
    for func in implicated_functions:
        aggregated = np.maximum(aggregated, func)
    return aggregated

Étape 5 : Défuzzification - Comparaison de 3 Méthodes

Objectif : Convertir la fonction d'appartenance floue agrégée en une valeur numérique unique (pression de freinage).

Le système compare 3 méthodes de défuzzification en temps réel :

1. Centroïde (COG) - Recommandée

Formule : x_COG = ∫x·μ(x)dx / ∫μ(x)dx

Description : Centre de gravité de la surface sous la fonction agrégée.

def defuzzify_centroid(universe, aggregated_mf):
    """Calcule le centroïde (centre de gravité)"""
    numerator = np.sum(universe * aggregated_mf)
    denominator = np.sum(aggregated_mf)
    return numerator / denominator if denominator != 0 else 0

# Exemple : Centroïde = 59.24

Avantages : Prend en compte toute la fonction, résultat lisse et stable Inconvénients : Plus coûteux en calcul

2. Premier Maximum (FOM)

Formule : x_FOM = min{x | μ(x) = max(μ)}

Description : Première valeur où la fonction atteint son maximum.

def defuzzify_first_of_maxima(universe, aggregated_mf):
    """Trouve le premier maximum"""
    max_value = np.max(aggregated_mf)
    indices = np.where(aggregated_mf == max_value)[0]
    return universe[indices[0]]

# Exemple : FOM = 34.00

Avantages : Rapide, favorise les décisions immédiates Inconvénients : Ignore une partie de l'information

3. Milieu de Noyau (MOM)

Formule : x_MOM = (a + b) / 2 où μ(a) = μ(b) = max(μ)

Description : Milieu du plateau maximal.

def defuzzify_mean_of_maxima(universe, aggregated_mf):
    """Calcule le milieu du noyau"""
    max_value = np.max(aggregated_mf)
    indices = np.where(aggregated_mf == max_value)[0]
    return (universe[indices[0]] + universe[indices[-1]]) / 2

# Exemple : MOM = 50.00

Avantages : Compromis entre COG et FOM Inconvénients : Peut donner des résultats inattendus si le plateau est large

Comparaison Visuelle :

Distance = 30m, Vitesse = 60 km/h

┌─────────────────────┬─────────┬────────────┐
│ Méthode             │ Valeur  │ Niveau     │
├─────────────────────┼─────────┼────────────┤
│ Centroïde (COG)     │ 59.24   │ Moyen      │ ← Recommandé
│ Premier Max (FOM)   │ 34.00   │ Faible     │
│ Milieu Noyau (MOM)  │ 50.00   │ Moyen      │
└─────────────────────┴─────────┴────────────┘