%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %% > [!nav] > ↩ [[Analyse et Données/Data Science/Data Mining/Data Mining|Accueil · Data Mining]] > > | [[Analyse et Données/Data Science/Data Mining/Cours 2 - Data mining avec python\|← Cours 2 - Data mining avec python]] | [[Analyse et Données/Data Science/Data Mining/Exercices\|Exercices →]] | > |:---|---:| %% nav-fin %% # Visuels avec Seaborn et Plotly pour le Data Mining > [!note] Liens avec les pré-requis et les compétences futures > Les compétences acquises lors du **pré-traitement des données** sont essentielles ici. Nous partirons du principe que vos données sont déjà propres, structurées et que les types de variables sont corrects. La visualisation sera votre première étape vers la **modélisation en apprentissage supervisé**, en vous aidant à identifier les relations entre variables, à détecter les *features* pertinentes et à comprendre la distribution des cibles. ### Objectifs du chapitre À la fin de ce chapitre, vous serez capable de : 1. Comprendre l'importance de la visualisation dans le processus de Data Mining. 2. Utiliser Seaborn pour créer une variété de graphiques statistiques statiques pour l'analyse univariée, bivariée et multivariée. 3. Utiliser Plotly Express pour générer des visualisations interactives et explorer des données complexes. 4. Choisir la bibliothèque et le type de graphique appropriés en fonction du contexte et du type de données. 5. Appliquer les bonnes pratiques de visualisation pour une communication claire et efficace. Préparez-vous à donner vie à vos données ! # L'importance de la Visualisation en Data Mining La visualisation de données est bien plus qu'une simple illustration ; c'est un outil analytique puissant. Avant de plonger dans des algorithmes complexes, il est impératif de "parler" à vos données, de les laisser vous raconter leur histoire. > [!definition] Analyse Exploratoire des Données (AED ou EDA) > L'Analyse Exploratoire des Données (Exploratory Data Analysis - EDA) est une approche d'analyse des jeux de données pour résumer leurs principales caractéristiques, souvent avec des méthodes visuelles. Une AED peut être utilisée pour découvrir des *patterns*, détecter des anomalies, tester des hypothèses et vérifier les hypothèses avec des modèles statistiques. ## Pourquoi visualiser ? - **Compréhension Intuitive** : Le cerveau humain est particulièrement doué pour reconnaître des *patterns* visuels. Un graphique peut révéler une tendance ou une relation qu'un tableau de chiffres ne pourrait jamais montrer aussi clairement. - **Détection d'Anomalies et d'Outliers** : Les valeurs aberrantes (outliers) ou les erreurs de saisie sont souvent flagrantes sur un graphique, mais difficiles à repérer dans de grands jeux de données bruts. - **Identification de Relations** : Visualiser la relation entre deux ou plusieurs variables peut révéler des corrélations, des groupements (clusters) ou des séparations qui seront cruciales pour la modélisation. - **Validation des Hypothèses** : Les visualisations permettent de vérifier rapidement si les hypothèses faites sur les données (par exemple, normalité d'une distribution) sont plausibles. - **Communication des Résultats** : Un graphique bien conçu est le moyen le plus efficace de communiquer des informations complexes à un public, qu'il soit technique ou non technique. - **Aide à la Prise de Décision** : En rendant les données accessibles et compréhensibles, la visualisation facilite la prise de décisions éclairées. > [!tip] La Règle d'Anscombe > Pour illustrer la nécessité de la visualisation, la "Règle d'Anscombe" est un ensemble de quatre jeux de données qui ont des propriétés statistiques identiques (moyenne, variance, corrélation, régression linéaire), mais qui sont visuellement très différents. Seule la visualisation permet de comprendre leurs véritables structures. # Seaborn pour l'Analyse Exploratoire Statique Seaborn est une bibliothèque de visualisation de données Python basée sur Matplotlib. Elle fournit une interface de haut niveau pour dessiner des graphiques statistiques attrayants et informatifs. ## Introduction à Seaborn - **Basé sur Matplotlib** : Seaborn étend les capacités de Matplotlib, offrant des *defaults* plus esthétiques et des fonctions spécialisées pour les visualisations statistiques. Vous pouvez toujours utiliser les fonctions de Matplotlib pour personnaliser davantage vos graphiques Seaborn. - **Focus Statistique** : Il est conçu pour explorer les relations entre plusieurs variables, en particulier pour les données multivariées. - **Installation** : ```bash pip install seaborn matplotlib pandas ``` - **Importation** : ```python import seaborn as sns import matplotlib.pyplot as plt import pandas as pd # Appliquer un thème Seaborn pour des graphiques plus esthétiques sns.set_theme(style="whitegrid") ``` > [!note] Convention > Dans les exemples de code, nous utiliserons `df` pour représenter un DataFrame Pandas contenant vos données. ## Visualisation de Variables Univariées L'analyse univariée consiste à examiner la distribution d'une seule variable. ### Variables Numériques - **Histogramme et KDE (`sns.histplot`, `sns.kdeplot`, `sns.displot`)** - Un histogramme montre la distribution de fréquence d'une variable numérique. - Une estimation de la densité de noyau (KDE - Kernel Density Estimate) est une méthode non-paramétrique pour estimer la fonction de densité de probabilité d'une variable aléatoire. Elle lisse l'histogramme pour donner une courbe continue. - `displot` est une fonction polyvalente qui peut combiner histogramme, KDE et ECDF (Empirical Cumulative Distribution Function). ```python # Histogramme sns.histplot(data=df, x='colonne_numerique', kde=True) plt.title('Distribution de la Colonne Numérique') plt.show() # KDE seule sns.kdeplot(data=df, x='colonne_numerique') plt.title('Estimation de Densité de Noyau') plt.show() # Displot avec histogramme et KDE sns.displot(data=df, x='colonne_numerique', kind='hist', kde=True) plt.title('Distribution avec Hist et KDE') plt.show() ``` > [!definition] Estimation de la Densité de Noyau (KDE) > La KDE estime la fonction de densité de probabilité $f(x)$ d'une variable aléatoire à partir d'un échantillon de données. Pour un ensemble de $n$ points de données $x_1, x_2, \dots, x_n$, la KDE est donnée par : > $ \hat{f}_h(x) = \frac{1}{n h} \sum_{i=1}^{n} K\left(\frac{x - x_i}{h}\right) $ > où $K(\cdot)$ est une fonction noyau (souvent gaussienne) et $h > 0$ est le paramètre de lissage (bande passante). - **Boîte à Moustaches (`sns.boxplot`)** - Affiche la distribution d'une variable numérique à travers ses quartiles, la médiane et les valeurs aberrantes potentielles. - Utile pour identifier la symétrie, la dispersion et les outliers. ```python sns.boxplot(data=df, y='colonne_numerique') plt.title('Boîte à Moustaches de la Colonne Numérique') plt.show() ``` ### Variables Catégoriques - **Diagramme en Barres (`sns.countplot`)** - Affiche le nombre d'occurrences de chaque catégorie dans une variable. - Idéal pour visualiser la distribution de fréquences des variables discrètes ou catégoriques. ```python sns.countplot(data=df, x='colonne_categorie') plt.title('Distribution de la Colonne Catégorique') plt.xticks(rotation=45) # Rotation des étiquettes si elles se chevauchent plt.show() ``` ## Visualisation de Variables Bivariées L'analyse bivariée examine la relation entre deux variables. ### Numérique vs Numérique - **Nuage de Points (`sns.scatterplot`)** - Montre la relation entre deux variables numériques. Chaque point représente une observation. - Permet de détecter des corrélations, des clusters ou des *patterns*. ```python sns.scatterplot(data=df, x='colonne_num1', y='colonne_num2') plt.title('Relation entre Num1 et Num2') plt.show() ``` - **Diagramme de Régression (`sns.regplot`, `sns.lmplot`)** - Ajoute une ligne de régression linéaire et un intervalle de confiance à un nuage de points. - `lmplot` est plus flexible et permet de séparer les données par des variables catégoriques (`hue`, `col`, `row`). ```python sns.regplot(data=df, x='colonne_num1', y='colonne_num2') plt.title('Régression Linéaire entre Num1 et Num2') plt.show() # Exemple avec lmplot et une variable catégorique pour la couleur sns.lmplot(data=df, x='colonne_num1', y='colonne_num2', hue='colonne_categorie') plt.title('Régression par Catégorie') plt.show() ``` - **Jointplot (`sns.jointplot`)** - Combine un nuage de points avec les distributions univariées (histogrammes ou KDE) des deux variables sur les marges. - Utile pour comprendre à la fois la relation bivariée et les distributions individuelles. ```python sns.jointplot(data=df, x='colonne_num1', y='colonne_num2', kind='scatter') # 'kde', 'hist', 'reg' plt.suptitle('Jointplot de Num1 et Num2', y=1.02) # Ajuster le titre plt.show() ``` ### Numérique vs Catégorique - **Boîte à Moustaches ou Violinplot (`sns.boxplot`, `sns.violinplot`)** - Compare la distribution d'une variable numérique à travers différentes catégories. - `violinplot` combine le boxplot avec une estimation de la densité de noyau, montrant la forme de la distribution à chaque niveau catégorique. ```python sns.boxplot(data=df, x='colonne_categorie', y='colonne_numerique') plt.title('Distribution Numérique par Catégorie') plt.show() sns.violinplot(data=df, x='colonne_categorie', y='colonne_numerique') plt.title('Violinplot Numérique par Catégorie') plt.show() ``` - **Stripplot et Swarmplot (`sns.stripplot`, `sns.swarmplot`)** - Affichent tous les points de données pour une variable numérique, séparés par une variable catégorique. - `stripplot` peut avoir des points qui se chevauchent. - `swarmplot` ajuste les points pour éviter le chevauchement, donnant une meilleure idée de la densité. ```python sns.stripplot(data=df, x='colonne_categorie', y='colonne_numerique', jitter=True) plt.title('Stripplot Numérique par Catégorie') plt.show() sns.swarmplot(data=df, x='colonne_categorie', y='colonne_numerique') plt.title('Swarmplot Numérique par Catégorie') plt.show() ``` ### Catégorique vs Catégorique - **Diagramme en Barres Groupées/Empilées (`sns.countplot` avec `hue`)** - Affiche la distribution de deux variables catégoriques. ```python sns.countplot(data=df, x='colonne_cat1', hue='colonne_cat2') plt.title('Distribution de Cat1 par Cat2') plt.show() ``` - **Heatmap d'une Table de Contingence (`sns.heatmap`)** - Visualise la fréquence ou la proportion des combinaisons de catégories. Nécessite de créer une table de contingence (par exemple, avec `pd.crosstab`). ```python contingency_table = pd.crosstab(df['colonne_cat1'], df['colonne_cat2']) sns.heatmap(contingency_table, annot=True, fmt='d', cmap='viridis') plt.title('Heatmap de la Table de Contingence') plt.show() ``` ## Visualisation de Variables Multivariées Lorsque vous avez trois variables ou plus, la visualisation devient plus complexe mais aussi plus révélatrice. - **Pairplot (`sns.pairplot`)** - Crée une grille de nuages de points pour chaque paire de variables numériques, et des histogrammes (ou KDE) pour les distributions univariées sur la diagonale. - Peut inclure une variable catégorique pour la couleur (`hue`). - Extrêmement utile pour une exploration rapide de toutes les relations bivariées. ```python sns.pairplot(df[['colonne_num1', 'colonne_num2', 'colonne_num3', 'colonne_categorie']], hue='colonne_categorie') plt.suptitle('Pairplot des Variables Numériques par Catégorie', y=1.02) plt.show() ``` - **Heatmap de Matrice de Corrélation (`sns.heatmap`)** - Visualise la matrice de corrélation entre les variables numériques. - Les couleurs indiquent la force et la direction de la corrélation. ```python correlation_matrix = df[['colonne_num1', 'colonne_num2', 'colonne_num3']].corr() sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f") plt.title('Matrice de Corrélation') plt.show() ``` > [!definition] Coefficient de Corrélation de Pearson > Le coefficient de corrélation de Pearson ($r$) mesure la force et la direction d'une relation linéaire entre deux variables $X$ et $Y$. Il est défini comme : > $ r = \frac{\sum_{i=1}^n (x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum_{i=1}^n (x_i - \bar{x})^2 \sum_{i=1}^n (y_i - \bar{y})^2}} $ > où $\bar{x}$ et $\bar{y}$ sont les moyennes de $X$ et $Y$. $r$ varie de -1 (corrélation linéaire négative parfaite) à +1 (corrélation linéaire positive parfaite), avec 0 indiquant l'absence de corrélation linéaire. # Personnalisation et Thèmes Seaborn offre de nombreuses options pour personnaliser l'apparence de vos graphiques : - `sns.set_theme()` : Définit le thème par défaut (ex: `darkgrid`, `whitegrid`, `dark`, `white`, `ticks`). - `sns.set_palette()` : Choisit une palette de couleurs (ex: `viridis`, `plasma`, `magma`, `rocket`). - Les fonctions Matplotlib (`plt.title()`, `plt.xlabel()`, `plt.ylabel()`, `plt.xticks()`, `plt.legend()`, `plt.figure(figsize=...)`) peuvent toujours être utilisées pour un contrôle fin. > [!tip] Toujours `plt.show()` > N'oubliez pas d'appeler `plt.show()` après chaque graphique (ou groupe de graphiques) pour l'afficher et libérer les ressources. Dans un environnement Jupyter/IPython, le graphique s'affiche souvent automatiquement, mais c'est une bonne pratique. # Plotly pour l'Analyse Exploratoire Interactive Plotly est une bibliothèque de visualisation qui permet de créer des graphiques interactifs basés sur le web. Contrairement à Seaborn/Matplotlib qui produisent des images statiques, les graphiques Plotly sont dynamiques : vous pouvez zoomer, faire un panoramique, afficher des informations détaillées au survol (tooltips) et même filtrer les données directement dans le graphique. ## Introduction à Plotly - **Interactivité Native** : Les graphiques sont interactifs par défaut, ce qui est excellent pour l'exploration de données et la présentation. - **Basé sur le Web** : Les graphiques sont rendus en JavaScript (via la bibliothèque `plotly.js`), ce qui les rend facilement intégrables dans des applications web (comme Dash) ou des notebooks. - **Plotly Express** : C'est une API de haut niveau (comme Seaborn) qui simplifie la création de graphiques Plotly complexes avec une seule ligne de code. Nous nous concentrerons principalement sur Plotly Express. - **Installation** : ```bash pip install plotly pandas ``` - **Importation** : ```python import plotly.express as px import pandas as pd ``` ## Visualisation de Variables Univariées ### Variables Numériques - **Histogramme (`px.histogram`)** - Similaire à `sns.histplot`, mais interactif. ```python fig = px.histogram(df, x='colonne_numerique', title='Distribution de la Colonne Numérique') fig.show() ``` - **Boîte à Moustaches et Violinplot (`px.box`, `px.violin`)** - Interactifs, permettent d'explorer les points individuels. ```python fig = px.box(df, y='colonne_numerique', title='Boîte à Moustaches de la Colonne Numérique') fig.show() fig = px.violin(df, y='colonne_numerique', title='Violinplot de la Colonne Numérique') fig.show() ``` ### Variables Catégoriques - **Diagramme en Barres (`px.bar`)** - Pour les fréquences de catégories. ```python fig = px.bar(df, x='colonne_categorie', title='Distribution de la Colonne Catégorique') fig.show() ``` ## Visualisation de Variables Bivariées ### Numérique vs Numérique - **Nuage de Points (`px.scatter`)** - Le graphique interactif par excellence. Vous pouvez survoler les points pour voir les détails, zoomer, déplacer. - Peut inclure des dimensions supplémentaires avec `color`, `size`, `symbol`. ```python fig = px.scatter(df, x='colonne_num1', y='colonne_num2', title='Relation entre Num1 et Num2', hover_data=['colonne_autre'], # Informations supplémentaires au survol color='colonne_categorie') # Couleur par catégorie fig.show() ``` - **Graphique Linéaire (`px.line`)** - Idéal pour les séries temporelles ou les données ordonnées. ```python # Exemple avec une colonne temporelle # df['date'] = pd.to_datetime(df['date']) # df = df.sort_values('date') fig = px.line(df, x='date_colonne', y='valeur_colonne', title='Évolution au fil du temps') fig.show() ``` ### Numérique vs Catégorique - **Boîte à Moustaches ou Violinplot (`px.box`, `px.violin`)** - Avec une variable catégorique sur l'axe X. ```python fig = px.box(df, x='colonne_categorie', y='colonne_numerique', title='Distribution Numérique par Catégorie') fig.show() ``` ### Catégorique vs Catégorique - **Diagramme en Barres Empilées/Groupées (`px.bar` avec `color`)** ```python fig = px.bar(df, x='colonne_cat1', color='colonne_cat2', title='Distribution de Cat1 par Cat2') fig.show() ``` ## Visualisation de Variables Multivariées et Avancées Plotly Express excelle dans la visualisation de données de haute dimension. - **Matrice de Nuages de Points (`px.scatter_matrix`)** - L'équivalent interactif du `sns.pairplot`. ```python fig = px.scatter_matrix(df, dimensions=['colonne_num1', 'colonne_num2', 'colonne_num3'], color='colonne_categorie', title='Matrice de Nuages de Points Interactifs') fig.show() ``` - **Coordonnées Parallèles (`px.parallel_coordinates`)** - Excellent pour visualiser des données de haute dimension et identifier des *patterns* ou des clusters. Chaque ligne représente une observation, et chaque axe une variable. ```python fig = px.parallel_coordinates(df, dimensions=['colonne_num1', 'colonne_num2', 'colonne_num3', 'colonne_num4'], color='colonne_cible', # Colorer par une variable cible color_continuous_scale=px.colors.sequential.Viridis, title='Coordonnées Parallèles') fig.show() ``` > [!note] Utilité des Coordonnées Parallèles > Ce type de graphique est particulièrement utile pour l'ingénierie des *features* et la compréhension des relations complexes avant l'apprentissage supervisé. Il permet de voir comment les différentes *features* se comportent pour différentes classes (si `color` est la variable cible). - **Heatmap (`px.density_heatmap`)** - Pour des données continues bivariées, montrant la densité des points. ```python fig = px.density_heatmap(df, x='colonne_num1', y='colonne_num2', title='Heatmap de Densité') fig.show() ``` - **Graphiques Hiérarchiques (`px.treemap`, `px.sunburst`)** - Pour visualiser des données structurées hiérarchiquement. ```python # Exemple Treemap (nécessite des colonnes représentant la hiérarchie) # fig = px.treemap(df, path=['continent', 'pays', 'ville'], values='population') # fig.show() ``` ## Interactivité Spécifique à Plotly - **Tooltips (Hover Information)** : Affichent les valeurs exactes des points au survol. Personnalisable avec `hover_name` et `hover_data`. - **Zoom et Panoramique** : Possibilité de se concentrer sur des régions spécifiques du graphique. - **Sélection** : Outils de sélection (rectangle, lasso) pour isoler des sous-ensembles de données. - **Légendes Interactives** : Clic sur la légende pour masquer/afficher des séries. - **Export** : Les graphiques peuvent être exportés en PNG, SVG ou JSON. > [!tip] Utilisation en Notebooks > Plotly fonctionne parfaitement dans les notebooks Jupyter et Google Colab, rendant l'exploration interactive très fluide. # Choisir entre Seaborn et Plotly (et quand les combiner) Le choix entre Seaborn et Plotly dépend de vos besoins spécifiques. Souvent, les deux sont utilisés de manière complémentaire. | Caractéristique | Seaborn (avec Matplotlib) | Plotly (avec Plotly Express) | | :-------------------- | :--------------------------------------------------------- | :---------------------------------------------------------------- | | **Interactivité** | Statique (images) | Interactive (zoom, pan, hover, sélection) | | **Complexité d'usage**| Facile pour les bases, plus de contrôle avec Matplotlib | Très facile avec Plotly Express, plus complexe pour Plotly Graph Objects | | **Esthétique** | Très bon par défaut, personnalisable | Très bon par défaut, moderne | | **Performance** | Rapide pour les grands jeux de données (rendu statique) | Peut être plus lent avec des très grands jeux de données (rendu JS) | | **Partage** | Images (PNG, JPG), PDF | Fichiers HTML, JSON, intégration web (Dash) | | **Cas d'usage idéal** | Rapports statiques, publications, exploration initiale rapide | Exploration interactive approfondie, dashboards, applications web | | **Dépendances** | Matplotlib | JavaScript (plotly.js) | ### Quand utiliser Seaborn ? - Pour une **exploration rapide et une vue d'ensemble** de la distribution et des relations. - Pour des **rapports statiques** ou des présentations où l'interactivité n'est pas requise. - Lorsque vous avez besoin d'un **contrôle très fin** sur chaque aspect esthétique du graphique (en utilisant Matplotlib). - Pour des **visualisations de diagnostic** rapides pendant le développement de modèles. ### Quand utiliser Plotly ? - Pour une **exploration approfondie et dynamique** des données, en permettant aux utilisateurs de "creuser" dans les détails. - Lorsque vous avez besoin de **partager des visualisations interactives** avec des collaborateurs ou des clients. - Pour construire des **dashboards interactifs** (avec Dash). - Pour des **données de haute dimension** où l'interactivité (coordonnées parallèles, scatter matrix) aide à la compréhension. ### Combiner les deux Une approche courante en Data Mining est de commencer par Seaborn pour une **analyse exploratoire initiale rapide et statique**. Cela permet d'obtenir un aperçu général, de détecter les problèmes majeurs et de formuler des hypothèses. Ensuite, pour les relations ou les *features* qui semblent particulièrement intéressantes, on passe à **Plotly pour une exploration interactive plus poussée**. Cela permet de valider les hypothèses, d'identifier des sous-groupes ou des *patterns* complexes qui pourraient être masqués dans un graphique statique. > [!example] Workflow combiné > 1. Utiliser `sns.pairplot()` pour avoir une vue d'ensemble des relations entre toutes les variables numériques. > 2. Si une relation spécifique entre `X` et `Y` semble intéressante (ex: une corrélation non linéaire ou des clusters), utiliser `px.scatter(df, x='X', y='Y', color='Z')` pour explorer cette relation de manière interactive, en ajoutant une troisième variable `Z` pour la couleur afin de voir son influence. > 3. Si une variable cible est présente, utiliser `sns.boxplot()` ou `sns.violinplot()` pour voir la distribution de chaque *feature* par rapport à la cible, puis `px.parallel_coordinates()` pour voir comment les *features* interagissent pour différentes classes de la cible. # Bonnes Pratiques de Visualisation pour le Data Mining Créer un graphique est une chose, créer un graphique efficace en est une autre. Voici quelques principes clés : 1. **Clarté et Simplicité** : Le graphique doit être compréhensible au premier coup d'œil. Évitez les informations superflues. 2. **Choix du Bon Type de Graphique** : - Distribution d'une variable numérique : histogramme, KDE, boxplot, violinplot. - Distribution d'une variable catégorique : barres (countplot). - Relation Numérique vs Numérique : nuage de points, régression, jointplot. - Relation Numérique vs Catégorique : boxplot, violinplot, stripplot. - Relation Catégorique vs Catégorique : barres groupées/empilées, heatmap de contingence. - Relations multivariées : pairplot, heatmap de corrélation, coordonnées parallèles. 3. **Étiquettes et Titres Clairs** : Chaque axe doit être étiqueté, le graphique doit avoir un titre descriptif et les légendes doivent être compréhensibles. 4. **Gestion des Couleurs** : - Utilisez des palettes de couleurs appropriées (séquentielles pour des valeurs continues, divergentes pour des valeurs avec un point central, catégoriques pour des catégories distinctes). - Tenez compte du daltonisme. - N'utilisez pas trop de couleurs différentes, cela peut être déroutant. 5. **Éviter la Surcharge d'Information** : Trop d'éléments sur un même graphique le rend illisible. Si nécessaire, créez plusieurs graphiques plus simples. 6. **Cohérence** : Utilisez des échelles, des couleurs et des styles cohérents dans une série de graphiques. 7. **Contexte** : Fournissez toujours le contexte nécessaire pour interpréter le graphique. 8. **Considérations Éthiques** : - Ne manipulez jamais les échelles d'axes pour induire en erreur (par exemple, commencer l'axe Y à une valeur non nulle pour exagérer les différences). - Soyez honnête quant aux limites de vos données et de vos visualisations. > [!warning] Piège courant : Corrélation n'implique pas Causalité > Un nuage de points montrant une forte corrélation entre deux variables ne signifie pas nécessairement que l'une cause l'autre. Il peut y avoir une troisième variable (variable confondante) qui influence les deux, ou la corrélation peut être purement accidentelle. La visualisation aide à identifier la corrélation, mais l'interprétation causale demande une expertise métier et des méthodes statistiques plus avancées. %% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %% > [!nav] > ↩ [[Analyse et Données/Data Science/Data Mining/Data Mining|Accueil · Data Mining]] > > | [[Analyse et Données/Data Science/Data Mining/Cours 2 - Data mining avec python\|← Cours 2 - Data mining avec python]] | [[Analyse et Données/Data Science/Data Mining/Exercices\|Exercices →]] | > |:---|---:| %% nav-fin %%