%% 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 →]] |
> |:---|---:|
%% nav-fin %%
# Introduction au Data Mining : Extraire la Connaissance des Données
Le Data Mining, souvent traduit par "exploration de données", est une discipline à l'intersection de l'informatique, des statistiques, de l'intelligence artificielle (IA) et de l'apprentissage automatique (Machine Learning). Son objectif principal n'est pas simplement de stocker ou d'organiser des données, mais de **découvrir des patterns, des tendances, des anomalies ou des relations significatives et inattendues** au sein de vastes et complexes ensembles de données.
> [!definition] Définition : Data Mining
> Le Data Mining est le processus itératif et systématique d'extraction de **patterns intéressants et non-triviaux** (connaissances, règles, régularités) à partir de grandes quantités de données. Ces patterns doivent idéalement posséder les caractéristiques suivantes :
> - **Validité** : Se vérifient avec un degré de certitude sur de nouvelles données.
> - **Nouveauté** : Représentent une connaissance jusqu'alors inconnue ou non évidente.
> - **Utilité / Actionnabilité** : Peuvent être utilisés pour la prise de décision, l'amélioration de processus ou la compréhension de phénomènes.
> - **Compréhensibilité** : Peuvent être interprétés et compris par des experts du domaine.
## Un Bref Historique et l'Importance Actuelle du Data Mining
Bien que le terme "Data Mining" soit apparu dans les années 1990, ses racines sont bien plus profondes, puisant dans les statistiques inférentielles, l'analyse multivariée et l'intelligence artificielle des décennies précédentes. Ce qui a propulsé le Data Mining au-devant de la scène, c'est la convergence de plusieurs facteurs :
1. **L'Explosion des Données (Big Data)** : La numérisation de nos sociétés génère des volumes de données sans précédent (transactions en ligne, réseaux sociaux, capteurs IoT, dossiers médicaux, etc.).
2. **La Puissance de Calcul Accrue** : Des processeurs plus rapides et des infrastructures de calcul distribué (cloud computing) permettent de traiter ces volumes massifs.
3. **L'Amélioration des Algorithmes** : Des avancées continues en Machine Learning et en IA ont rendu les algorithmes plus performants et capables de gérer des données complexes.
4. **La Réduction des Coûts de Stockage** : Le stockage de grandes quantités de données est devenu économiquement viable.
Aujourd'hui, le Data Mining est un pilier de la transformation numérique, omniprésent et crucial dans presque tous les secteurs :
- **Commerce de Détail et E-commerce** :
- **Recommandation de produits** (Amazon, Netflix) : "Les clients qui ont acheté X ont aussi acheté Y."
- **Segmentation client** : Identifier des groupes de clients aux comportements similaires pour des campagnes marketing ciblées.
- **Optimisation des prix et des stocks**.
- **Santé et Biotechnologies** :
- **Diagnostic assisté** : Prédire la probabilité d'une maladie à partir de symptômes et d'historiques.
- **Découverte de médicaments** : Identifier des molécules prometteuses.
- **Prédiction d'épidémies** ou de risques de santé publique.
- **Finance et Assurances** :
- **Détection de fraudes** (cartes de crédit, assurances) : Repérer des transactions ou des réclamations inhabituelles.
- **Évaluation du risque de crédit** : Prédire la probabilité qu'un emprunteur fasse défaut.
- **Trading algorithmique** : Identifier des patterns sur les marchés financiers.
- **Industrie et Fabrication** :
- **Maintenance prédictive** : Anticiper les pannes de machines pour intervenir avant qu'elles ne surviennent.
- **Optimisation des processus de production** et contrôle qualité.
- **Télécommunications** :
- **Prédiction de la défaillance client (churn)** : Identifier les clients susceptibles de résilier leur abonnement.
- **Optimisation des réseaux**.
- **Recherche Scientifique** : Analyse de données génomiques, astronomiques, climatiques, etc.
## Objectifs Fondamentaux du Data Mining
Les objectifs du Data Mining peuvent être regroupés en deux grandes catégories, souvent complémentaires :
1. **Objectifs Descriptifs** : Ils visent à résumer, caractériser et comprendre les propriétés générales des données et les relations qu'elles contiennent. Il s'agit de répondre à la question "Que s'est-il passé et pourquoi ?".
* *Exemples* : Identifier des groupes de clients similaires, découvrir des associations entre produits.
2. **Objectifs Prédictifs** : Ils visent à inférer des valeurs futures ou inconnues à partir de données existantes. Il s'agit de répondre à la question "Que va-t-il se passer ?".
* *Exemples* : Prédire le prix d'une maison, anticiper la défaillance d'un client.
> [!note] Data Mining vs. Statistiques vs. Machine Learning
> Bien que ces domaines soient fortement interconnectés, il est utile de distinguer leurs nuances :
> - **Statistiques** : Fournissent les fondements mathématiques et les méthodes d'analyse pour tester des hypothèses, quantifier l'incertitude et établir des inférences sur des populations à partir d'échantillons. Elles sont souvent *hypothético-déductives*.
> - **Data Mining** : Applique des techniques statistiques, informatiques et d'IA pour découvrir des patterns dans de grands jeux de données, souvent de manière *exploratoire* et sans hypothèse *a priori* forte. Il est plus orienté vers l'extraction de connaissances à partir de données massives et hétérogènes.
> - **Machine Learning (ML)** : Est un sous-domaine de l'IA qui fournit les algorithmes permettant aux systèmes d'apprendre des données et de réaliser des tâches spécifiques (prédiction, classification, regroupement) sans programmation explicite. Le Data Mining utilise massivement les algorithmes de Machine Learning comme ses outils principaux.
> En bref, le Data Mining est le *processus* d'extraction de connaissance, et le Machine Learning est l'*ensemble d'outils algorithmiques* souvent utilisés dans ce processus.
# Les Grandes Familles de Tâches de Data Mining : Votre Boîte à Outils
Les tâches de Data Mining sont diverses et peuvent être classées selon plusieurs axes, notamment selon qu'elles sont descriptives ou prédictives, et si elles relèvent de l'apprentissage supervisé ou non-supervisé.
## Apprentissage Supervisé vs. Non-Supervisé : Une Distinction Cruciale
Cette distinction est fondamentale et guide le choix des algorithmes et la préparation des données.
> [!definition] Apprentissage Supervisé
> L'apprentissage supervisé implique l'utilisation d'un ensemble de données d'entraînement où les **labels** (ou "cibles", "variables dépendantes", $y$) sont déjà connus. L'objectif est d'apprendre une fonction $f$ qui mappe les entrées ($X$) aux sorties ($y$), afin de prédire les labels pour de nouvelles données non étiquetées.
> $ y = f(X) $
> Les tâches principales sont la **Classification** et la **Régression**.
> [!definition] Apprentissage Non-Supervisé
> L'apprentissage non-supervisé travaille avec des données qui ne sont **pas étiquetées**. L'objectif est de découvrir des structures cachées, des patterns, des groupes ou des relations au sein des données elles-mêmes, sans l'aide d'une variable cible pré-définie. Il s'agit souvent d'une tâche exploratoire et descriptive.
> Les tâches principales sont le **Clustering**, la **Réduction de Dimensionnalité** et les **Règles d'Association**.
## Détail des Tâches Principales avec des Exemples Scikit-learn
Voici les tâches de Data Mining les plus courantes, illustrées par des exemples concrets utilisant des jeux de données de `scikit-learn`.
### Classification (Supervisé, Prédictif)
La classification est une tâche d'apprentissage supervisé qui consiste à assigner une instance de données à une catégorie (classe) prédéfinie. La variable cible est **catégorielle** (discrète).
> [!example] Exemples d'Applications de Classification
> - **Diagnostic médical** : Classer une tumeur comme `bénigne` ou `maligne` à partir d'examens.
> - **Détection de spam** : Classer un email comme `spam` ou `non-spam`.
> - **Prédiction de la défaillance client (churn)** : Un opérateur télécom veut prédire si un client va résilier son abonnement (classes : `Oui`, `Non`).
> - **Reconnaissance d'images** : Identifier un objet dans une image (ex: chat, chien, voiture).
> [!tip] Rappel sur le Prétraitement pour la Classification
> Pour la classification, il est crucial que les variables d'entrée (features $X$) soient bien préparées : gestion des valeurs manquantes, encodage des variables catégorielles (`OneHotEncoder`, `LabelEncoder`), normalisation/standardisation des données numériques (`StandardScaler`, `MinMaxScaler`).
```python
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
# 1. Chargement du jeu de données Iris
# Le jeu de données Iris est un classique pour la classification,
# il contient des mesures de sépales et pétales pour 3 espèces de fleurs d'iris.
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names) # Features
y = pd.Series(iris.target) # Cible (espèces de fleurs : 0, 1, 2)
print("Aperçu des features (X):")
print(X.head())
print("\nAperçu de la cible (y):")
print(y.value_counts())
# 2. Division des données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 3. Instanciation et entraînement d'un modèle de classification (Arbre de Décision)
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)
# 4. Prédiction sur l'ensemble de test
y_pred = model.predict(X_test)
# 5. Évaluation du modèle
accuracy = accuracy_score(y_test, y_pred)
print(f"\nPrécision du modèle sur l'ensemble de test: {accuracy:.2f}")
# Utilité du Data Mining ici:
# Le modèle entraîné peut maintenant prédire l'espèce d'une nouvelle fleur d'iris
# en se basant sur ses mesures, ce qui est utile pour l'identification botanique automatisée.
```
### Régression (Supervisé, Prédictif)
La régression est une tâche d'apprentissage supervisé qui vise à prédire une valeur continue (numérique). La variable cible est **numérique**.
> [!example] Exemples d'Applications de Régression
> - **Prédiction du prix d'une maison** : Estimer le prix de vente en fonction de sa surface, du nombre de pièces, de sa localisation, etc.
> - **Prévision des ventes** : Prédire les ventes d'un produit pour le mois prochain ou l'année prochaine.
> - **Estimation de la consommation d'énergie** : Prédire la consommation électrique d'un bâtiment en fonction de la météo, de l'occupation, etc.
> - **Prévision boursière** : Anticiper le cours d'une action.
```python
import pandas as pd
from sklearn.datasets import fetch_california_housing # Utiliser California Housing car Boston est déprécié
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import numpy as np
# 1. Chargement du jeu de données California Housing
# Ce dataset contient des informations sur les maisons en Californie et leurs prix médians.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names) # Features
y = pd.Series(housing.target) # Cible (prix médian des maisons, en centaines de milliers de dollars)
print("Aperçu des features (X):")
print(X.head())
print("\nAperçu de la cible (y) - quelques valeurs:")
print(y.head())
# 2. Division des données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 3. Instanciation et entraînement d'un modèle de régression (Régression Linéaire)
model = LinearRegression()
model.fit(X_train, y_train)
# 4. Prédiction sur l'ensemble de test
y_pred = model.predict(X_test)
# 5. Évaluation du modèle (RMSE - Root Mean Squared Error)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
print(f"\nRMSE du modèle sur l'ensemble de test: {rmse:.2f}")
# Utilité du Data Mining ici:
# Ce modèle peut aider des agents immobiliers ou des acheteurs à estimer le prix d'une propriété
# en fonction de ses caractéristiques, offrant une base pour la négociation ou l'investissement.
```
### Clustering (Non-Supervisé, Descriptif)
Le clustering (ou partitionnement) est une tâche non-supervisée qui regroupe des instances de données similaires en clusters, sans connaissance préalable des groupes. L'objectif est de maximiser la similarité intra-cluster (points à l'intérieur d'un même cluster sont proches) et de minimiser la similarité inter-cluster (points de clusters différents sont éloignés).
> [!example] Exemples d'Applications de Clustering
> - **Segmentation client** : Regrouper les clients en segments homogènes basés sur leur comportement d'achat, leurs données démographiques, etc., pour des campagnes marketing ciblées.
> - **Analyse d'images** : Regrouper des pixels de couleurs similaires pour la compression ou la segmentation d'images.
> - **Détection d'anomalies** : Les points qui ne s'intègrent à aucun cluster ou forment de très petits clusters peuvent être des anomalies.
> - **Regroupement de documents** : Organiser de vastes collections de textes par thèmes similaires.
> [!note] Mesure de Similarité/Distance
> Le clustering repose sur la notion de similarité ou de distance entre les points de données. La **distance euclidienne** est un exemple courant :
> Pour deux points $p = (p_1, p_2, ..., p_n)$ et $q = (q_1, q_2, ..., q_n)$ dans un espace à $n$ dimensions, la distance euclidienne est :
> $ d(p, q) = \sqrt{\sum_{i=1}^{n} (q_i - p_i)^2} $
> D'autres métriques existent, comme la distance de Manhattan ou la similarité cosinus. Le choix dépend du type de données et de l'objectif.
```python
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import seaborn as sns
# 1. Chargement du jeu de données Iris (cette fois, nous ignorons les labels pour le clustering)
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
print("Aperçu des features pour le clustering:")
print(X.head())
# 2. Prétraitement : Standardisation des features (très important pour le K-Means)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# 3. Instanciation et entraînement d'un modèle de clustering (K-Means)
# Nous choisissons K=3 car nous savons qu'il y a 3 espèces d'iris, mais en pratique,
# le nombre optimal de clusters est déterminé par des méthodes comme la "méthode du coude".
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10) # n_init pour éviter les problèmes d'initialisation
kmeans.fit(X_scaled)
# 4. Obtention des labels de cluster
clusters = kmeans.labels_
X_with_clusters = X.copy()
X_with_clusters['cluster'] = clusters
print("\nPremières lignes avec les clusters assignés:")
print(X_with_clusters.head())
print("\nDistribution des points par cluster:")
print(X_with_clusters['cluster'].value_counts())
# 5. Visualisation des clusters (en 2D pour la simplicité)
# Utilisation de PCA pour réduire la dimensionnalité à 2D pour la visualisation
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
X_pca_df = pd.DataFrame(data = X_pca, columns = ['principal component 1', 'principal component 2'])
X_pca_df['cluster'] = clusters
plt.figure(figsize=(8, 6))
sns.scatterplot(x='principal component 1', y='principal component 2', hue='cluster', data=X_pca_df, palette='viridis', s=100, alpha=0.8)
plt.title('Clusters K-Means des fleurs d\'Iris (après PCA)')
plt.xlabel('Composante Principale 1')
plt.ylabel('Composante Principale 2')
plt.legend(title='Cluster')
plt.grid(True)
plt.show()
# Utilité du Data Mining ici:
# Sans connaître les espèces à l'avance, le clustering a regroupé les fleurs qui se ressemblent.
# Cela peut être utilisé pour découvrir des sous-populations naturelles dans des données clients,
# des types de défauts dans des produits, ou des genres de musique, etc.
```
### Règles d'Association (Non-Supervisé, Descriptif)
Les règles d'association identifient des relations de type "si... alors..." entre des éléments (items) dans de grands ensembles de données, souvent des transactions. Elles sont très utilisées pour l'analyse du panier d'achat.
> [!example] Exemple de Règles d'Association
> - **Analyse du panier d'achat** : "Si un client achète des couches et du lait, alors il est probable qu'il achète aussi des lingettes." (Règle: `{couches, lait} => {lingettes}`)
> - **Organisation de supermarché** : Placer des produits souvent achetés ensemble à proximité pour maximiser les ventes.
> - **Optimisation de catalogues en ligne** : Suggérer des produits complémentaires.
> - **Détection d'anomalies** : Une transaction qui viole une règle d'association forte pourrait être suspecte.
> [!theorem] Métriques Clés des Règles d'Association
> Les règles d'association sont évaluées par des métriques clés pour juger de leur force et de leur intérêt :
> - **Support (Support)** : Indique la fréquence d'apparition de l'ensemble d'items (l'antécédent et le conséquent ensemble, $X \cup Y$) dans toutes les transactions. C'est la probabilité $P(X \cup Y)$.
> $ Support(X \Rightarrow Y) = P(X \cup Y) = \frac{\text{Nombre de transactions contenant X et Y}}{\text{Nombre total de transactions}} $
> - **Confiance (Confidence)** : Mesure la fiabilité de la règle. C'est la probabilité que Y soit acheté sachant que X a été acheté. $P(Y | X)$.
> $ Confidence(X \Rightarrow Y) = P(Y | X) = \frac{P(X \cup Y)}{P(X)} = \frac{Support(X \Rightarrow Y)}{Support(X)} $
> - **Lift (Élévation)** : Mesure l'association entre X et Y, au-delà de ce qui serait attendu par le hasard. Un Lift > 1 indique une association positive (X et Y sont achetés ensemble plus souvent que par hasard). Un Lift < 1 indique une association négative. Un Lift = 1 indique qu'il n'y a pas d'association.
> $ Lift(X \Rightarrow Y) = \frac{Confidence(X \Rightarrow Y)}{P(Y)} = \frac{Support(X \Rightarrow Y)}{Support(X) \times Support(Y)} $
> [!note] Implémentation en Python
> `Scikit-learn` ne propose pas d'implémentation directe pour les règles d'association. Des bibliothèques comme `mlxtend` sont couramment utilisées pour cela, notamment l'algorithme Apriori.
### Détection d'Anomalies (Supervisé ou Non-Supervisé, Descriptif/Prédictif)
La détection d'anomalies (ou détection d'outliers) vise à identifier des observations qui s'écartent significativement du comportement normal ou attendu des données. Ces points sont souvent rares mais peuvent indiquer des événements critiques.
> [!example] Exemples d'Applications de Détection d'Anomalies
> - **Détection de fraude bancaire** : Identifier des transactions inhabituelles (montant, lieu, fréquence) sur une carte de crédit.
> - **Surveillance de réseaux** : Détecter des intrusions, des attaques DDoS ou des comportements malveillants sur un réseau informatique.
> - **Maintenance prédictive** : Repérer des dysfonctionnements anormaux dans les capteurs de machines industrielles avant qu'une panne majeure ne survienne.
> - **Contrôle qualité** : Identifier des produits défectueux sur une chaîne de production.
```python
import pandas as pd
from sklearn.datasets import make_blobs # Générer des données avec des clusters
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt
import numpy as np
# 1. Génération de données avec quelques anomalies
X, _ = make_blobs(n_samples=300, centers=1, random_state=42, cluster_std=1.0)
# Ajout de quelques outliers manuellement
rng = np.random.RandomState(42)
X_outliers = rng.uniform(low=-6, high=6, size=(20, 2))
X = np.concatenate([X, X_outliers], axis=0)
X_df = pd.DataFrame(X, columns=['feature_1', 'feature_2'])
print("Aperçu des données (avec outliers):")
print(X_df.head())
# 2. Instanciation et entraînement d'un modèle de détection d'anomalies (Isolation Forest)
# L'Isolation Forest "isole" les anomalies en les séparant rapidement du reste des données.
# 'contamination' est la proportion attendue d'anomalies dans le dataset.
model = IsolationForest(contamination=0.05, random_state=42)
model.fit(X_df)
# 3. Prédiction des anomalies (-1 pour outlier, 1 pour inlier)
outliers_pred = model.predict(X_df)
# 4. Visualisation des résultats
plt.figure(figsize=(10, 7))
sns.scatterplot(x='feature_1', y='feature_2', hue=outliers_pred, palette='coolwarm', s=100, data=X_df)
plt.title('Détection d\'Anomalies avec Isolation Forest')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend(title='Type', labels=['Anomalie', 'Normal'])
plt.grid(True)
plt.show()
# Utilité du Data Mining ici:
# Ce type de modèle permet de signaler automatiquement des comportements ou des points de données
# qui s'écartent de la norme, alertant les opérateurs sur des problèmes potentiels
# ou des activités suspectes qui nécessitent une investigation humaine.
```
### Réduction de Dimensionnalité (Non-Supervisé, Descriptif)
Cette tâche vise à réduire le nombre de variables (dimensions) d'un jeu de données tout en conservant autant d'informations pertinentes que possible. Cela offre de multiples avantages :
- **Visualisation des données** : Faciliter la représentation graphique de données de haute dimension.
- **Réduction du temps de calcul** : Moins de features signifie des modèles plus rapides à entraîner.
- **Amélioration des performances** : Éviter la "malédiction de la dimensionnalité" (curse of dimensionality) et réduire le bruit.
- **Stockage optimisé**.
> [!example] Exemples d'Applications de Réduction de Dimensionnalité
> - **Analyse en Composantes Principales (ACP/PCA)** : Transformer un ensemble de variables corrélées en un nouvel ensemble de variables non corrélées appelées composantes principales, qui capturent la majeure partie de la variance.
> - **Visualisation de données complexes** : Projeter des données de haute dimension (ex: images, textes) sur 2 ou 3 dimensions pour les rendre visualisables.
> - **Compression de données**.
```python
import pandas as pd
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import seaborn as sns
# 1. Chargement du jeu de données Digits
# Ce dataset contient des images de chiffres manuscrits (8x8 pixels = 64 features).
digits = load_digits()
X = pd.DataFrame(digits.data) # 64 features
y = pd.Series(digits.target) # Cible (le chiffre représenté)
print("Forme des features originales:", X.shape)
print("Aperçu des features (premières colonnes):")
print(X.head())
# 2. Instanciation et application de la PCA
# Nous réduisons les 64 dimensions à seulement 2 pour la visualisation.
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
X_pca_df = pd.DataFrame(data = X_pca, columns = ['principal component 1', 'principal component 2'])
X_pca_df['digit'] = y
print("\nForme des features après PCA:", X_pca_df.shape)
print("Aperçu des features après PCA:")
print(X_pca_df.head())
# 3. Visualisation des données réduites en 2D
plt.figure(figsize=(10, 8))
sns.scatterplot(x='principal component 1', y='principal component 2', hue='digit',
palette='tab10', legend='full', data=X_pca_df, s=50, alpha=0.8)
plt.title('Visualisation des chiffres manuscrits avec PCA (2 Composantes Principales)')
plt.xlabel('Composante Principale 1')
plt.ylabel('Composante Principale 2')
plt.grid(True)
plt.show()
# Utilité du Data Mining ici:
# La réduction de dimensionnalité permet de visualiser des données très complexes (64 dimensions ici)
# dans un espace intelligible (2D), révélant des structures cachées (les chiffres sont bien regroupés).
# C'est aussi crucial pour améliorer l'efficacité et la performance des algorithmes de ML ultérieurs.
```
# Le Data Mining dans le Processus KDD : Un Cycle Vertueux
Le Data Mining n'est pas une activité isolée, mais une étape centrale d'un processus plus large et itératif appelé **Knowledge Discovery in Databases (KDD)**, ou "Découverte de Connaissances dans les Bases de Données". Comprendre ce processus est essentiel pour mener à bien un projet de Data Mining.
Le processus KDD se décompose généralement en plusieurs étapes clés :
1. **Compréhension du Problème et des Données (Business Understanding & Data Understanding)** :
* Définir clairement les objectifs du projet (que voulons-nous découvrir ? quel problème résoudre ?).
* Identifier les sources de données pertinentes et les comprendre (type, format, signification des attributs).
* Évaluer la faisabilité et les contraintes (éthiques, légales, techniques).
2. **Sélection des Données (Data Selection)** :
* Identifier et extraire les sous-ensembles de données pertinents à partir de diverses sources (bases de données, entrepôts de données, fichiers plats, APIs).
* Cela peut impliquer des requêtes SQL complexes, des scripts Python pour l'extraction web, etc.
3. **Prétraitement des Données (Data Preprocessing / Data Cleaning)** :
* C'est l'étape la plus longue et souvent la plus cruciale d'un projet de Data Science. Vous l'avez explorée en profondeur avec **Python et Pandas**.
* **Nettoyage des données** : Gestion des valeurs manquantes (imputation, suppression), détection et correction des erreurs, suppression des doublons, traitement des valeurs aberrantes (outliers).
* **Intégration des données** : Fusionner des données provenant de différentes sources.
* **Réduction des données** : Réduire le nombre d'observations ou de variables sans perdre d'informations cruciales.
4. **Transformation des Données (Data Transformation)** :
* Conversion des données dans un format approprié pour les algorithmes de Data Mining.
* **Normalisation/Standardisation** : Mettre les données à la même échelle pour éviter que certaines features ne dominent d'autres (ex: `StandardScaler`, `MinMaxScaler`).
* **Encodage** : Convertir les variables catégorielles en format numérique (ex: `OneHotEncoder`, `LabelEncoder`).
* **Création de nouvelles variables (Feature Engineering)** : Construire des features plus informatives à partir des features existantes (ex: âge à partir de la date de naissance, ratio).
* **Agrégation** : Résumer des données à un niveau plus élevé.
* **Réduction de dimensionnalité** : Utiliser des techniques comme la PCA pour réduire le nombre de features.
5. **Data Mining (Application des Algorithmes)** :
* C'est l'étape où les algorithmes d'exploration de données sont appliqués aux données préparées.
* Choix de la tâche de Data Mining (classification, régression, clustering, etc.) en fonction des objectifs définis.
* Sélection et application des algorithmes appropriés (ex: `DecisionTreeClassifier`, `KMeans`, `LinearRegression`).
* Ajustement des paramètres des algorithmes.
6. **Évaluation et Interprétation des Patterns (Pattern Evaluation & Interpretation)** :
* Analyse des patterns découverts pour déterminer leur validité, leur nouveauté, leur utilité et leur compréhensibilité.
* Utilisation de métriques d'évaluation (précision, rappel, F1-score pour la classification ; RMSE pour la régression ; silhouette score pour le clustering).
* Visualisation des résultats pour faciliter l'interprétation.
* Consultation d'experts du domaine pour valider la pertinence des connaissances extraites.
7. **Déploiement / Utilisation des Connaissances (Knowledge Deployment)** :
* Intégration des connaissances découvertes dans un système opérationnel, une application, un rapport ou une prise de décision concrète.
* Cela peut impliquer la mise en production d'un modèle prédictif, l'ajustement de stratégies marketing, l'amélioration d'un processus industriel, etc.
> [!warning] Le processus KDD n'est pas linéaire !
> Il s'agit d'un cycle itératif. Par exemple, l'évaluation des patterns (étape 6) peut révéler la nécessité d'un prétraitement supplémentaire, d'une nouvelle transformation des données, ou même d'une modification des objectifs initiaux. Des allers-retours entre les étapes sont fréquents et nécessaires pour affiner les résultats.
# Outils et Écosystème Python pour le Data Mining
Python est devenu le langage de prédilection pour la Data Science et le Data Mining, grâce à son écosystème riche en bibliothèques performantes, flexibles et faciles à utiliser.
## Pandas : Votre Allié Indispensable pour la Manipulation de Données
Vous connaissez déjà `pandas` pour le prétraitement et la manipulation de données tabulaires. Son rôle est central tout au long du processus KDD, de la sélection à la transformation des données.
- **Chargement et exploration** : `pd.read_csv()`, `df.head()`, `df.info()`, `df.describe()`.
- **Manipulation de données** : Filtrage, sélection de colonnes, jointures (`merge`), regroupements (`groupby`), gestion des valeurs manquantes (`fillna`, `dropna`).
- **Préparation pour les modèles** : C'est souvent à partir d'un DataFrame `pandas` que vous préparerez vos matrices de features ($X$) et vos vecteurs cibles ($y$) pour les algorithmes de Machine Learning.
```python
import pandas as pd
# Exemple de chargement et d'exploration
# df = pd.read_csv('mon_dataset.csv')
# print(df.head())
# print(df.isnull().sum()) # Vérifier les valeurs manquantes par colonne
# print(df.describe()) # Statistiques descriptives
```
## NumPy : Le Calcul Numérique de Haute Performance
`NumPy` (Numerical Python) est la bibliothèque fondamentale pour le calcul scientifique avec Python. Elle fournit un objet tableau multidimensionnel (`ndarray`) et des fonctions pour opérer sur ces tableaux de manière extrêmement efficace. La quasi-totalité des autres bibliothèques de Data Science s'appuient sur `NumPy` pour leurs opérations numériques.
```python
import numpy as np
# Création d'un tableau NumPy
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Tableau NumPy:\n", data)
print("Dimensions du tableau (shape):", data.shape)
print("Somme de tous les éléments:", np.sum(data))
print("Moyenne par colonne:", np.mean(data, axis=0)) # axis=0 pour les colonnes
```
### 4.3. Scikit-learn : Le Couteau Suisse du Machine Learning
`Scikit-learn` est la bibliothèque la plus populaire et la plus complète pour le Machine Learning en Python. Elle implémente une vaste gamme d'algorithmes de Data Mining et offre une API cohérente et intuitive pour tous ses modèles.
> [!tip] La philosophie Scikit-learn (API cohérente)
> `Scikit-learn` suit un modèle d'API simple et cohérent qui facilite l'apprentissage et l'utilisation :
> 1. **Instancier** un modèle : `model = NomDuModele(parametres)`
> 2. **Entraîner** le modèle : `model.fit(X_train, y_train)` (pour l'apprentissage supervisé) ou `model.fit(X)` (pour l'apprentissage non-supervisé)
> 3. **Prédire** ou **Transformer** : `predictions = model.predict(X_test)` ou `X_transformed = model.transform(X)`
`Scikit-learn` couvre les modules suivants, essentiels pour le Data Mining :
- **Classification** : `LogisticRegression`, `DecisionTreeClassifier`, `RandomForestClassifier`, `SVC` (Support Vector Classifier).
- **Régression** : `LinearRegression`, `RandomForestRegressor`, `SVR` (Support Vector Regressor).
- **Clustering** : `KMeans`, `DBSCAN`, `AgglomerativeClustering`.
- **Réduction de dimensionnalité** : `PCA` (Principal Component Analysis), `TSNE` (t-Distributed Stochastic Neighbor Embedding).
- **Prétraitement** : `StandardScaler`, `MinMaxScaler`, `OneHotEncoder`, `LabelEncoder`.
- **Sélection de modèles et évaluation** : `train_test_split`, `cross_val_score`, `GridSearchCV`, `accuracy_score`, `mean_squared_error`.
## Matplotlib et Seaborn : La Visualisation des Données, un Impératif
La visualisation est une étape cruciale à toutes les phases du processus KDD. Elle permet de :
- **Comprendre les données** (exploration, détection d'outliers).
- **Explorer les patterns** découverts par les algorithmes.
- **Présenter les résultats** de manière claire et impactante.
- **Évaluer la qualité** des modèles.
- `Matplotlib` : La bibliothèque de base pour créer des graphiques statiques, animés et interactifs en Python. Elle offre un contrôle fin sur chaque élément graphique.
- `Seaborn` : Basé sur `Matplotlib`, il fournit une interface de haut niveau pour créer des graphiques statistiques attrayants et informatifs avec moins de code. Idéal pour l'exploration de données et la visualisation de distributions.
```python
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
# Exemple de visualisation simple
data_dist = np.random.normal(loc=0, scale=1, size=1000) # Données normales
plt.figure(figsize=(8, 5))
sns.histplot(data_dist, kde=True, color='skyblue')
plt.title('Distribution de données aléatoires')
plt.xlabel('Valeur')
plt.ylabel('Fréquence')
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()
```
# Considérations Éthiques et Limites du Data Mining
Le Data Mining est un outil puissant aux implications profondes. Son utilisation soulève des questions éthiques importantes et présente des limites intrinsèques qu'il est impératif de comprendre.
## Biais des Données et Discrimination
Les modèles de Data Mining apprennent des données qui leur sont fournies. Si ces données sont biaisées (par exemple, reflètent des inégalités historiques, représentent mal certaines populations ou contiennent des stéréotypes), le modèle va non seulement reproduire ces biais, mais potentiellement les amplifier et les pérenniser.
> [!warning] Attention aux biais algorithmiques !
> Un modèle de recrutement entraîné sur des données historiques où les hommes étaient majoritairement embauchés dans certains postes pourrait, sans ajustement et vérification, défavoriser systématiquement les candidatures féminines, même si le sexe n'est pas une variable explicite. De même, des systèmes de reconnaissance faciale peuvent être moins précis pour certaines ethnies. Il est crucial d'auditer les données et les performances des modèles sur différents sous-groupes.
## Confidentialité et Protection des Données (RGPD)
L'extraction de connaissances à partir de données personnelles soulève des préoccupations majeures en matière de vie privée. Le **RGPD (Règlement Général sur la Protection des Données)** en Europe impose des règles strictes sur la collecte, le traitement, le stockage et la protection des données personnelles.
> [!note] Principes Clés du RGPD pour les ingénieurs
> - **Licéité, Loyauté, Transparence** : Traiter les données de manière légale, équitable et transparente.
> - **Limitation des Finalités** : Collecter les données pour des finalités déterminées, explicites et légitimes.
> - **Minimisation des Données** : Ne collecter et traiter que les données strictement nécessaires.
> - **Exactitude** : S'assurer que les données sont exactes et à jour.
> - **Limitation de la Conservation** : Conserver les données uniquement le temps nécessaire.
> - **Intégrité et Confidentialité** : Protéger les données contre les accès non autorisés ou la destruction.
> - **Responsabilité** : Le responsable du traitement doit pouvoir démontrer le respect de ces principes.
> - **Droits des personnes concernées** : Droit d'accès, de rectification, à l'oubli, à la limitation du traitement, à la portabilité, d'opposition.
## Interprétabilité et Explicabilité des Modèles (XAI)
Certains modèles de Data Mining, notamment les réseaux de neurones profonds, sont très performants mais peuvent être difficiles à interpréter. On les qualifie de modèles "boîte noire". Comprendre *pourquoi* un modèle prend une certaine décision est crucial, surtout dans des domaines sensibles comme la santé (diagnostic), la justice (évaluation du risque de récidive) ou la finance (octroi de prêt).
Le domaine de l'**Explicable AI (XAI)** vise à développer des méthodes pour rendre les modèles plus transparents et compréhensibles par l'humain.
## Surapprentissage (Overfitting) et Sous-apprentissage (Underfitting)
Deux pièges courants dans la construction de modèles de Data Mining :
- **Surapprentissage (Overfitting)** : Un modèle est dit en surapprentissage lorsqu'il a "appris par cœur" les données d'entraînement, y compris le bruit et les spécificités qui ne sont pas généralisables. Il performera très bien sur les données d'entraînement mais très mal sur de nouvelles données jamais vues.
- **Sous-apprentissage (Underfitting)** : Un modèle est en sous-apprentissage lorsqu'il est trop simple pour capturer la structure sous-jacente des données. Il ne performe bien ni sur les données d'entraînement ni sur les nouvelles données.
> [!tip] Comment lutter contre le surapprentissage et le sous-apprentissage ?
> - **Plus de données d'entraînement** (pour overfitting).
> - **Réduction de la complexité du modèle** (pour overfitting) ou **Augmentation de la complexité** (pour underfitting).
> - **Validation croisée (Cross-validation)** : Pour évaluer la généralisabilité du modèle de manière robuste.
> - **Techniques de régularisation** (L1, L2) : Pour pénaliser les modèles trop complexes.
> - **Arrêt précoce (Early stopping)** : Pour arrêter l'entraînement avant que le modèle ne commence à surapprendre.
> - **Sélection de features** : Choisir les features les plus pertinentes.
%% 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 →]] |
> |:---|---:|
%% nav-fin %%