xplia 1.0.1__py3-none-any.whl

xplia/visualizations/gauge_chart.py

@@ -0,0 +1,211 @@
+"""
+Implémentation des graphiques de type jauge (gauge charts) pour XPLIA
+"""
+
+def create_gauge_chart(data, config, library="plotly", **kwargs):
+    """
+    Crée un graphique de type jauge avec la bibliothèque spécifiée.
+    
+    Args:
+        data: Valeur ou données pour la jauge
+        config: Configuration du graphique
+        library: Bibliothèque à utiliser
+        **kwargs: Arguments spécifiques au type de graphique
+        
+    Returns:
+        Objet graphique selon la bibliothèque utilisée
+    """
+    if library == "plotly":
+        return _create_plotly_gauge_chart(data, config, **kwargs)
+    elif library == "matplotlib":
+        return _create_mpl_gauge_chart(data, config, **kwargs)
+    elif library == "bokeh":
+        return _create_bokeh_gauge_chart(data, config, **kwargs)
+    else:
+        raise ValueError(f"Bibliothèque {library} non supportée pour les jauges")
+
+# Implémentations spécifiques
+def _create_plotly_gauge_chart(data, config, **kwargs):
+    """Implémentation Plotly des jauges"""
+    import plotly.graph_objects as go
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    width = config.get('width', 500)
+    height = config.get('height', 500)
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        # Format {value: X, min: Y, max: Z, ...}
+        value = data.get('value', 0)
+        minimum = data.get('min', 0)
+        maximum = data.get('max', 100)
+        threshold = data.get('threshold', None)
+        steps = data.get('steps', None)
+    else:
+        # Format simple: valeur directe
+        value = data if isinstance(data, (int, float)) else data[0]
+        minimum = kwargs.get('min', 0)
+        maximum = kwargs.get('max', 100)
+        threshold = kwargs.get('threshold', None)
+        steps = kwargs.get('steps', None)
+    
+    # Configuration des étapes de couleur
+    if steps is None:
+        # Valeurs par défaut pour une jauge à 3 zones
+        steps = [
+            {'range': [minimum, maximum * 0.6], 'color': 'lightgreen'},
+            {'range': [maximum * 0.6, maximum * 0.8], 'color': 'gold'},
+            {'range': [maximum * 0.8, maximum], 'color': 'firebrick'}
+        ]
+    
+    # Configuration de l'indicateur
+    gauge_bar_color = kwargs.get('gauge_bar_color', 'royalblue')
+    gauge_bar_thickness = kwargs.get('gauge_bar_thickness', 0.6)
+    show_axis_tick_labels = kwargs.get('show_axis_tick_labels', True)
+    
+    # Texte à afficher au centre de la jauge
+    delta_reference = kwargs.get('delta_reference', None)
+    delta_config = {}
+    if delta_reference is not None:
+        delta = value - delta_reference
+        delta_config = {
+            'reference': delta_reference,
+            'valueformat': kwargs.get('delta_format', '.1f'),
+            'relative': kwargs.get('delta_relative', False)
+        }
+    
+    # Configuration du mode de la jauge
+    gauge_mode = kwargs.get('gauge_mode', 'gauge+number')
+    
+    # Création du graphique
+    fig = go.Figure(go.Indicator(
+        mode=gauge_mode,
+        value=value,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        title={'text': title, 'font': {'size': kwargs.get('title_font_size', 24)}},
+        delta=delta_config,
+        gauge={
+            'axis': {
+                'range': [minimum, maximum],
+                'tickwidth': 1,
+                'tickcolor': 'darkblue',
+                'visible': show_axis_tick_labels
+            },
+            'bar': {'color': gauge_bar_color, 'thickness': gauge_bar_thickness},
+            'bgcolor': 'white',
+            'borderwidth': 2,
+            'bordercolor': 'gray',
+            'steps': steps,
+            'threshold': {
+                'line': {'color': 'black', 'width': 4},
+                'thickness': 0.75,
+                'value': threshold
+            }
+        }
+    ))
+    
+    # Configuration du layout
+    fig.update_layout(
+        width=width,
+        height=height,
+        margin=dict(t=50, b=25, l=25, r=25)
+    )
+            
+    return fig
+
+def _create_mpl_gauge_chart(data, config, **kwargs):
+    """Implémentation Matplotlib des jauges"""
+    import matplotlib.pyplot as plt
+    import numpy as np
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    
+    # Normalisation des données
+    if isinstance(data, dict):
+        value = data.get('value', 0)
+        minimum = data.get('min', 0)
+        maximum = data.get('max', 100)
+        threshold = data.get('threshold', None)
+        steps = data.get('steps', None)
+    else:
+        value = data if isinstance(data, (int, float)) else data[0]
+        minimum = kwargs.get('min', 0)
+        maximum = kwargs.get('max', 100)
+        threshold = kwargs.get('threshold', None)
+        steps = kwargs.get('steps', None)
+    
+    # Configuration des étapes de couleur
+    if steps is None:
+        # Valeurs par défaut pour une jauge à 3 zones
+        steps = [
+            {'range': [minimum, maximum * 0.6], 'color': 'lightgreen'},
+            {'range': [maximum * 0.6, maximum * 0.8], 'color': 'gold'},
+            {'range': [maximum * 0.8, maximum], 'color': 'firebrick'}
+        ]
+    
+    # Création de la figure
+    fig, ax = plt.subplots(figsize=(
+        config.get('width', 500) / 100,
+        config.get('height', 500) / 100
+    ), subplot_kw={'projection': 'polar'})
+    
+    # Configuration de base pour la jauge
+    # La jauge est représentée par un diagramme polaire partiel
+    start_angle = np.pi/6
+    end_angle = 5*np.pi/6
+    
+    # Rendre la jauge semi-circulaire
+    ax.set_thetamin(90)  # commencer à 90° (bas)
+    ax.set_thetamax(270)  # terminer à 270° (haut)
+    
+    # Limites du rayon
+    ax.set_ylim(0, 1)
+    
+    # Dessiner les segments de couleur pour les étapes
+    for step in steps:
+        step_min, step_max = step['range']
+        color = step['color']
+        
+        # Normaliser les valeurs
+        norm_min = (step_min - minimum) / (maximum - minimum)
+        norm_max = (step_max - minimum) / (maximum - minimum)
+        
+        # Convertir en angles
+        angle_min = np.pi/2 + norm_min * np.pi
+        angle_max = np.pi/2 + norm_max * np.pi
+        
+        # Créer un set de points pour le secteur
+        theta = np.linspace(angle_min, angle_max, 30)
+        radii = np.ones_like(theta) * 0.8
+        
+        # Dessiner le segment
+        ax.fill_between(theta, 0, radii, color=color, alpha=0.8)
+    
+    # Dessiner la valeur actuelle
+    norm_value = (value - minimum) / (maximum - minimum)
+    value_angle = np.pi/2 + norm_value * np.pi
+    
+    # Flèche pointant vers la valeur actuelle
+    ax.plot([value_angle, value_angle], [0, 0.9], 'k-', lw=2)
+    ax.plot([value_angle, value_angle], [0.7, 0.9], 'k-', lw=6)
+    
+    # Ajouter le texte de la valeur au centre
+    ax.text(np.pi, 0.2, f"{value:.1f}", ha='center', va='center', fontsize=20)
+    
+    # Cacher les graduations et les étiquettes
+    ax.set_xticks([])
+    ax.set_yticks([])
+    
+    # Cacher les lignes de grille
+    ax.grid(False)
+    
+    # Cacher l'axe
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+    
+    # Ajouter le titre
+    plt.title(title, y=0.1)
+    
+    return fig

xplia/visualizations/gradient_viz.py

@@ -0,0 +1,117 @@
+"""
+GradientVisualizer pour XPLIA
+============================
+
+Ce module fournit un visualiseur interactif et modulaire pour les explications
+par gradient (vanilla, integrated, smoothgrad). Il supporte plusieurs types de
+données (tabulaire, image, texte) et s'adapte au niveau d'audience.
+"""
+
+from typing import Any
+from .base import VisualizerBase
+from .registry import register_visualizer
+from ..core.enums import ExplainabilityMethod, AudienceLevel
+
+@register_visualizer(ExplainabilityMethod.GRADIENT)
+class GradientVisualizer(VisualizerBase):
+    """
+    Visualiseur interactif pour les explications par gradient dans XPLIA.
+    
+    Ce visualiseur supporte les données tabulaires, images et texte, et adapte
+    la visualisation au niveau d'audience (technique, business, public).
+    """
+    def visualize(self, explanation_result, audience_level: AudienceLevel = AudienceLevel.TECHNICAL, **kwargs) -> Any:
+        """
+        Génère une visualisation à partir d'un résultat d'explication par gradient.
+        
+        Args:
+            explanation_result: Résultat d'explication (ExplanationResult)
+            audience_level: Niveau d'audience ciblé
+            **kwargs: Paramètres additionnels (ex: show_values, top_k, etc.)
+        Returns:
+            Objet de visualisation (Plotly Figure, Matplotlib Figure, HTML, ...)
+        """
+        input_type = explanation_result.metadata.input_type if hasattr(explanation_result, 'metadata') and hasattr(explanation_result.metadata, 'input_type') else kwargs.get('input_type', 'tabular')
+        feature_importances = explanation_result.feature_importances
+        
+        if input_type == 'tabular':
+            return self._visualize_tabular(feature_importances, audience_level, **kwargs)
+        elif input_type == 'image':
+            return self._visualize_image(explanation_result, audience_level, **kwargs)
+        elif input_type == 'text':
+            return self._visualize_text(feature_importances, audience_level, **kwargs)
+        else:
+            raise ValueError(f"Type d'entrée non supporté pour la visualisation gradient: {input_type}")
+    
+    def _visualize_tabular(self, feature_importances, audience_level, **kwargs):
+        import plotly.graph_objects as go
+        top_k = kwargs.get('top_k', 15)
+        show_values = kwargs.get('show_values', True)
+        features = [fi.feature_name for fi in feature_importances[:top_k]]
+        scores = [fi.importance_score for fi in feature_importances[:top_k]]
+        
+        fig = go.Figure(go.Bar(
+            x=scores,
+            y=features,
+            orientation='h',
+            marker_color=self._color_palette[0],
+            text=[f"{s:.2f}" for s in scores] if show_values else None,
+            textposition='auto'
+        ))
+        fig.update_layout(
+            title="Importances par gradient",
+            xaxis_title="Score d'importance",
+            yaxis_title="Caractéristique",
+            margin=dict(l=80, r=40, t=60, b=40)
+        )
+        fig = self._set_theme(fig)
+        fig = self._adapt_to_audience(fig, audience_level)
+        return fig
+    
+    def _visualize_image(self, explanation_result, audience_level, **kwargs):
+        import plotly.graph_objects as go
+        import numpy as np
+        # On suppose que explanation_result contient 'original_input' et 'attributions' (heatmap)
+        original = getattr(explanation_result, 'original_input', None)
+        attributions = getattr(explanation_result, 'attributions', None)
+        if attributions is None and hasattr(explanation_result, 'feature_importances'):
+            # fallback: reconstituer la heatmap à partir des importances
+            attributions = np.array([fi.importance_score for fi in explanation_result.feature_importances])
+            if original is not None and attributions.size == np.prod(original.shape):
+                attributions = attributions.reshape(original.shape)
+        if attributions is None:
+            raise ValueError("Impossible de visualiser l'attribution gradient pour image: aucune heatmap trouvée.")
+        if original is not None:
+            fig = go.Figure()
+            fig.add_trace(go.Image(z=original))
+            fig.add_trace(go.Heatmap(z=attributions, opacity=0.6, colorscale='RdBu', showscale=True, colorbar=dict(title='Attribution')))
+            fig.update_layout(title="Attributions par gradient (superposées)", margin=dict(l=40, r=40, t=60, b=40))
+        else:
+            fig = go.Figure(go.Heatmap(z=attributions, colorscale='RdBu', showscale=True, colorbar=dict(title='Attribution')))
+            fig.update_layout(title="Attributions par gradient", margin=dict(l=40, r=40, t=60, b=40))
+        fig = self._set_theme(fig)
+        fig = self._adapt_to_audience(fig, audience_level)
+        return fig
+    
+    def _visualize_text(self, feature_importances, audience_level, **kwargs):
+        import plotly.graph_objects as go
+        top_k = kwargs.get('top_k', 20)
+        tokens = [fi.feature_name for fi in feature_importances[:top_k]]
+        scores = [fi.importance_score for fi in feature_importances[:top_k]]
+        colors = [self._color_palette[0] if s >= 0 else self._color_palette[1] for s in scores]
+        fig = go.Figure(go.Bar(
+            x=tokens,
+            y=scores,
+            marker_color=colors,
+            text=[f"{s:.2f}" for s in scores],
+            textposition='auto'
+        ))
+        fig.update_layout(
+            title="Attribution par gradient sur les tokens",
+            xaxis_title="Token",
+            yaxis_title="Score d'importance",
+            margin=dict(l=60, r=40, t=60, b=40)
+        )
+        fig = self._set_theme(fig)
+        fig = self._adapt_to_audience(fig, audience_level)
+        return fig

xplia/visualizations/heatmap_chart.py

@@ -0,0 +1,173 @@
+"""
+Implémentation des cartes thermiques (heatmaps) pour XPLIA
+"""
+
+def create_heatmap(data, config, library="plotly", **kwargs):
+    """
+    Crée une carte thermique avec la bibliothèque spécifiée.
+    
+    Args:
+        data: Données pour le graphique (matrice 2D)
+        config: Configuration du graphique
+        library: Bibliothèque à utiliser
+        **kwargs: Arguments spécifiques au type de graphique
+        
+    Returns:
+        Objet graphique selon la bibliothèque utilisée
+    """
+    if library == "plotly":
+        return _create_plotly_heatmap(data, config, **kwargs)
+    elif library == "matplotlib":
+        return _create_mpl_heatmap(data, config, **kwargs)
+    elif library == "bokeh":
+        return _create_bokeh_heatmap(data, config, **kwargs)
+    else:
+        raise ValueError(f"Bibliothèque {library} non supportée pour les cartes thermiques")
+
+# Implémentations spécifiques
+def _create_plotly_heatmap(data, config, **kwargs):
+    """Implémentation Plotly des cartes thermiques"""
+    import plotly.graph_objects as go
+    import numpy as np
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    x_label = config.get('x_label', '')
+    y_label = config.get('y_label', '')
+    width = config.get('width', 800)
+    height = config.get('height', 600)
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        # Format {z: [...], x: [...], y: [...]}
+        z_data = data.get('z', [])
+        x_data = data.get('x', list(range(len(z_data[0]) if z_data and len(z_data) > 0 else 0)))
+        y_data = data.get('y', list(range(len(z_data) if z_data else 0)))
+    else:
+        # Format matrice 2D [z]
+        z_data = data
+        x_data = kwargs.get('x_labels', list(range(len(z_data[0]) if z_data and len(z_data) > 0 else 0)))
+        y_data = kwargs.get('y_labels', list(range(len(z_data) if z_data else 0)))
+    
+    # Vérification pour assurer que z_data est une liste de listes (matrice 2D)
+    if not all(isinstance(row, list) for row in z_data):
+        if isinstance(z_data, np.ndarray):
+            z_data = z_data.tolist()
+        else:
+            raise ValueError("Les données z doivent être une matrice 2D (liste de listes)")
+    
+    # Récupération des options personnalisées
+    colorscale = kwargs.get('colorscale', 'Viridis')
+    showscale = kwargs.get('showscale', True)
+    text_matrix = kwargs.get('text', None)
+    
+    # Création du graphique
+    fig = go.Figure(data=go.Heatmap(
+        z=z_data,
+        x=x_data,
+        y=y_data,
+        colorscale=colorscale,
+        showscale=showscale,
+        text=text_matrix,
+        hovertemplate=kwargs.get('hovertemplate', 
+                                 'x: %{x}<br>' +
+                                 'y: %{y}<br>' +
+                                 'z: %{z}<br>' +
+                                 '%{text}<extra></extra>'),
+        colorbar=dict(
+            title=kwargs.get('colorbar_title', ''),
+            titleside=kwargs.get('colorbar_titleside', 'right'),
+            ticks=kwargs.get('colorbar_ticks', "outside"),
+            tickfont=dict(
+                size=kwargs.get('colorbar_tickfont_size', 12)
+            )
+        ),
+        zauto=kwargs.get('zauto', True),
+        zmin=kwargs.get('zmin', None),
+        zmax=kwargs.get('zmax', None)
+    ))
+    
+    # Configuration du layout
+    fig.update_layout(
+        title=title,
+        xaxis_title=x_label,
+        yaxis_title=y_label,
+        width=width,
+        height=height,
+        xaxis=dict(
+            tickangle=kwargs.get('x_tickangle', -45)
+        )
+    )
+            
+    return fig
+
+def _create_mpl_heatmap(data, config, **kwargs):
+    """Implémentation Matplotlib des cartes thermiques"""
+    import matplotlib.pyplot as plt
+    import numpy as np
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    x_label = config.get('x_label', '')
+    y_label = config.get('y_label', '')
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        z_data = np.array(data.get('z', []))
+        x_data = data.get('x', list(range(z_data.shape[1] if z_data.size > 0 else 0)))
+        y_data = data.get('y', list(range(z_data.shape[0] if z_data.size > 0 else 0)))
+    else:
+        z_data = np.array(data)
+        x_data = kwargs.get('x_labels', list(range(z_data.shape[1] if z_data.size > 0 else 0)))
+        y_data = kwargs.get('y_labels', list(range(z_data.shape[0] if z_data.size > 0 else 0)))
+    
+    # Création de la figure
+    fig, ax = plt.subplots(figsize=(
+        config.get('width', 800) / 100,
+        config.get('height', 600) / 100
+    ))
+    
+    # Options de coloration
+    cmap = kwargs.get('colorscale', kwargs.get('cmap', 'viridis'))
+    vmin = kwargs.get('zmin', None)
+    vmax = kwargs.get('zmax', None)
+    
+    # Création de la carte thermique
+    im = ax.imshow(z_data, cmap=cmap, vmin=vmin, vmax=vmax, 
+                   aspect=kwargs.get('aspect', 'auto'))
+    
+    # Ajouter une barre de couleur
+    if kwargs.get('showscale', True):
+        cbar = fig.colorbar(im, ax=ax)
+        cbar.set_label(kwargs.get('colorbar_title', ''))
+    
+    # Configuration des titres et labels
+    ax.set_title(title)
+    ax.set_xlabel(x_label)
+    ax.set_ylabel(y_label)
+    
+    # Configurer les ticks pour x et y si spécifiés
+    if len(x_data) > 0:
+        if len(x_data) <= 30:  # Éviter trop de labels
+            ax.set_xticks(range(len(x_data)))
+            ax.set_xticklabels(x_data, rotation=kwargs.get('x_tickangle', 45))
+    
+    if len(y_data) > 0:
+        if len(y_data) <= 30:  # Éviter trop de labels
+            ax.set_yticks(range(len(y_data)))
+            ax.set_yticklabels(y_data)
+    
+    # Afficher les valeurs dans les cellules si demandé
+    if kwargs.get('show_values', False):
+        text_kw = kwargs.get('text_kw', {})
+        text_format = kwargs.get('text_format', '{:.2f}')
+        
+        # Pour chaque cellule
+        for i in range(z_data.shape[0]):
+            for j in range(z_data.shape[1]):
+                value = z_data[i, j]
+                text_color = 'black' if im.norm(value) > 0.5 else 'white'
+                ax.text(j, i, text_format.format(value), ha="center", va="center", 
+                        color=text_color, **text_kw)
+    
+    return fig

xplia/visualizations/histogram_chart.py

@@ -0,0 +1,176 @@
+"""
+Implémentation des histogrammes pour XPLIA
+"""
+
+def create_histogram_chart(data, config, library="plotly", **kwargs):
+    """
+    Crée un histogramme avec la bibliothèque spécifiée.
+    
+    Args:
+        data: Données pour l'histogramme
+        config: Configuration du graphique
+        library: Bibliothèque à utiliser
+        **kwargs: Arguments spécifiques au type de graphique
+        
+    Returns:
+        Objet graphique selon la bibliothèque utilisée
+    """
+    if library == "plotly":
+        return _create_plotly_histogram_chart(data, config, **kwargs)
+    elif library == "matplotlib":
+        return _create_mpl_histogram_chart(data, config, **kwargs)
+    elif library == "bokeh":
+        return _create_bokeh_histogram_chart(data, config, **kwargs)
+    else:
+        raise ValueError(f"Bibliothèque {library} non supportée pour les histogrammes")
+
+# Implémentations spécifiques
+def _create_plotly_histogram_chart(data, config, **kwargs):
+    """Implémentation Plotly des histogrammes"""
+    import plotly.graph_objects as go
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    x_label = config.get('x_label', '')
+    y_label = config.get('y_label', '')
+    width = config.get('width', 800)
+    height = config.get('height', 500)
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        # Format {x: [...], name: "...", ...} ou {series: [{x: [...], name: "...", ...}, ...]}
+        if 'series' in data:
+            # Multiple séries
+            series = data.get('series', [])
+        else:
+            # Une seule série
+            series = [data]
+    else:
+        # Format [data] ou [[data1], [data2], ...]
+        if all(isinstance(d, list) for d in data):
+            # Format [[data1], [data2], ...]
+            series = [{'x': d, 'name': f'Série {i+1}'} for i, d in enumerate(data)]
+        else:
+            # Format [data]
+            series = [{'x': data, 'name': kwargs.get('name', 'Données')}]
+    
+    # Création de la figure
+    fig = go.Figure()
+    
+    # Ajout de chaque série d'histogramme
+    for i, serie in enumerate(series):
+        color = serie.get('color', config.get('color_palette', [])[i % len(config.get('color_palette', ['#1f77b4']))])
+        
+        fig.add_trace(go.Histogram(
+            x=serie.get('x', []),
+            name=serie.get('name', f'Série {i}'),
+            marker_color=color,
+            opacity=kwargs.get('opacity', 0.7),
+            nbinsx=kwargs.get('nbins', None),
+            histnorm=kwargs.get('histnorm', None),  # '', 'percent', 'probability', 'density', 'probability density'
+            cumulative_enabled=kwargs.get('cumulative', False),
+            autobinx=True if kwargs.get('nbins') is None else False,
+            xbins=serie.get('xbins', {}),
+            marker_line_width=kwargs.get('marker_line_width', 1),
+            marker_line_color=kwargs.get('marker_line_color', "#FFFFFF"),
+            hoverinfo=kwargs.get('hoverinfo', 'x+y+name')
+        ))
+    
+    # Configuration du layout
+    fig.update_layout(
+        title=title,
+        xaxis_title=x_label,
+        yaxis_title=y_label,
+        width=width,
+        height=height,
+        barmode=kwargs.get('barmode', 'overlay'),  # 'overlay', 'stack', 'group', 'relative'
+        bargap=kwargs.get('bargap', 0),
+        bargroupgap=kwargs.get('bargroupgap', 0)
+    )
+    
+    # Configuration des axes
+    if 'x_range' in kwargs:
+        fig.update_xaxes(range=kwargs['x_range'])
+    if 'y_range' in kwargs:
+        fig.update_yaxes(range=kwargs['y_range'])
+        
+    return fig
+
+def _create_mpl_histogram_chart(data, config, **kwargs):
+    """Implémentation Matplotlib des histogrammes"""
+    import matplotlib.pyplot as plt
+    import numpy as np
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    x_label = config.get('x_label', '')
+    y_label = config.get('y_label', '')
+    
+    # Normalisation des données (similaire à Plotly)
+    if isinstance(data, dict):
+        if 'series' in data:
+            series = data.get('series', [])
+        else:
+            series = [data]
+    else:
+        if all(isinstance(d, list) for d in data):
+            series = [{'x': d, 'name': f'Série {i+1}'} for i, d in enumerate(data)]
+        else:
+            series = [{'x': data, 'name': kwargs.get('name', 'Données')}]
+    
+    # Création de la figure
+    fig, ax = plt.subplots(figsize=(
+        config.get('width', 800) / 100,
+        config.get('height', 500) / 100
+    ))
+    
+    # Options de l'histogramme
+    bins = kwargs.get('nbins', 'auto')
+    alpha = kwargs.get('opacity', 0.7)
+    density = kwargs.get('histnorm', None) in ['density', 'probability', 'probability density']
+    cumulative = kwargs.get('cumulative', False)
+    histtype = 'bar'
+    
+    if kwargs.get('barmode') == 'stack':
+        stacked = True
+    else:
+        stacked = False
+    
+    # Ajout de chaque série d'histogramme
+    for i, serie in enumerate(series):
+        color = serie.get('color', config.get('color_palette', [])[i % len(config.get('color_palette', ['#1f77b4']))])
+        
+        ax.hist(
+            serie.get('x', []),
+            bins=bins,
+            alpha=alpha,
+            density=density,
+            cumulative=cumulative,
+            histtype=histtype,
+            color=color,
+            label=serie.get('name', f'Série {i}'),
+            edgecolor=kwargs.get('marker_line_color', 'white'),
+            linewidth=kwargs.get('marker_line_width', 1),
+            stacked=stacked
+        )
+    
+    # Configuration des titres et labels
+    ax.set_title(title)
+    ax.set_xlabel(x_label)
+    ax.set_ylabel(y_label)
+    
+    # Ajout de la grille
+    if kwargs.get('grid', True):
+        ax.grid(True, linestyle='--', alpha=0.7)
+        
+    # Ajout de la légende
+    if kwargs.get('show_legend', True) and len(series) > 1:
+        ax.legend()
+    
+    # Configuration des axes
+    if 'x_range' in kwargs:
+        ax.set_xlim(kwargs['x_range'])
+    if 'y_range' in kwargs:
+        ax.set_ylim(kwargs['y_range'])
+    
+    return fig