Discrétisation

La discrétisation est le processus qui consiste à transformer des variables continues en variables discrètes en créant un ensemble d’intervalles contigus qui couvrent la gamme des valeurs de la variable. La discrétisation est également appelée binning, où bin est un nom alternatif pour l’intervalle.

La discrétisation permet de traiter les valeurs aberrantes et peut améliorer la répartition des valeurs dans les variables biaisées

La discrétisation aide à traiter les valeurs aberrantes en plaçant ces valeurs dans les intervalles inférieurs ou supérieurs, avec les valeurs restantes plus anciennes de la distribution. Ainsi, ces observations aberrantes ne diffèrent plus du reste des valeurs à la queue de la distribution, car elles sont maintenant toutes ensemble dans le même intervalle/seau. De plus, en créant des cases ou des intervalles appropriés, la discrétisation peut aider à répartir les valeurs d’une variable biaisée sur un ensemble de cases ayant un nombre égal d’observations.

Approches de la discrétisation

Il existe plusieurs approches pour transformer les variables continues en variables discrètes. Les méthodes de discrétisation se divisent en deux catégories : supervisée et non supervisée. Les méthodes non supervisées n’utilisent aucune information, autre que la distribution des variables, pour créer les bacs contigus dans lesquels les valeurs seront placées. Les méthodes supervisées utilisent généralement des informations cibles pour créer les bacs ou les intervalles.

Méthodes de discrétisation non supervisées

  • Discrétisation à largeur égale
  • Discrétisation à fréquence égale
  • La discrétisation de K-means

Méthodes de discrétisation supervisées

  • Discrétion à l’aide d’arbres de décision

Dans ce notebook je décrirai la discrétisation à largeur égale.

Discrétisation de largeur égale

La discrétisation à largeur égale divise l’étendue des valeurs possibles en N cases de même largeur. La largeur est déterminée par l’étendue des valeurs de la variable et le nombre de cases que nous souhaitons utiliser pour diviser la variable :

largeur = (valeur maximale – valeur minimale) / N

où N est le nombre de bacs ou d’intervalles.

Par exemple, si les valeurs de la variable varient entre 0 et 100, nous créons 5 bacs comme ceci : largeur = (100-0) / 5 = 20. Les bacs sont donc 0-20, 20-40, 40-60, 80-100. Le premier et le dernier bac (0-20 et 80-100) peuvent être élargis pour tenir compte des valeurs aberrantes (c’est-à-dire que les valeurs inférieures à 0 ou supérieures à 100 seraient également placées dans ces bacs).

Il n’y a pas de règle empirique pour définir N, c’est-à-dire quelque chose à déterminer expérimentalement.

Dans cette démo

Nous apprendrons comment effectuer un binning de largeur égale avec

  • Feature-engine
import pandas as pd
import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import KBinsDiscretizer

from feature_engine.discretisers import EqualWidthDiscretiser

data = pd.read_csv('../exportfeature.csv',usecols=['place', 'allocation', 'nAllocation', 'nbPartants'],sep=";",encoding='ANSI')


data.head()
place	allocation	nbPartants	nAllocation
0	1	90000.0	17	95000
1	1	70000.0	18	58000
2	0	44000.0	12	37000
3	1	40000.0	11	38000
4	0	40000.0	16	34000
# Création d enotre jeu de test et d'entrainement

X_train, X_test, y_train, y_test = train_test_split(
    data[['allocation', 'nAllocation', 'nbPartants']],
    data['place'],
    test_size=0.3,
    random_state=0)

X_train.shape, X_test.shape

((14352, 3), (6152, 3))

# cherchons les observations manquantes par variable
vars_with_na = [var for var in data.columns if data[var].isnull().mean() > 0]
vars_with_na

[]

Super aucune données manquantes.

# Explorons la distribution

data[['allocation', 'nAllocation', 'nbPartants']].hist(bins=30, figsize=(8,4))
plt.show()
distribution

Discrétisation à largeur égale avec Feature-Engine

# avec  Feature-Engine, nous pouvons automatiser le processus pour de nombreuses variables
# dans une ligne de code

disc = EqualWidthDiscretiser(bins=10, variables = ['allocation', 'nAllocation', 'nbPartants'])

disc.fit(X_train)

EqualWidthDiscretiser(variables=['allocation', 'nAllocation', 'nbPartants'])

# dans le binner dict, on peut voir les limites des intervalles. Pour l'allocation
# la valeur augmente d'environ 10 000 à chaque fois.

# Pour nAllocation c'est environ 60000
# Pour les partants on peut voir que notre système semble moins bien adapté. Il faudra plutot prendre 3-4 intervalles

disc.binner_dict_
{'allocation': [-inf,
  100000.9,
  200000.8,
  300000.69999999995,
  400000.6,
  500000.5,
  600000.3999999999,
  700000.2999999999,
  800000.2,
  900000.1,
  inf],
 'nAllocation': [-inf,
  600540.0,
  1200480.0,
  1800420.0,
  2400360.0,
  3000300.0,
  3600240.0,
  4200180.0,
  4800120.0,
  5400060.0,
  inf],
 'nbPartants': [-inf,
  5.4,
  6.8,
  8.2,
  9.6,
  11.0,
  12.399999999999999,
  13.799999999999999,
  15.2,
  16.6,
  inf]}
# Transformons nos valeurs

train_t = disc.transform(X_train)
test_t = disc.transform(X_test)

train_t.head()
	allocation	nAllocation	nbPartants
2540	0	0	8
19008	0	0	9
7624	0	0	9
2575	0	0	6
852	0	0	8
t1 = train_t.groupby(['allocation'])['allocation'].count() / len(train_t)
t2 = test_t.groupby(['allocation'])['allocation'].count() / len(test_t)

tmp = pd.concat([t1, t2], axis=1)
tmp.columns = ['train', 'test']
tmp.plot.bar()
plt.xticks(rotation=0)
plt.ylabel('Nombre d''observations')
alloc1
t1 = train_t.groupby(['nAllocation'])['nAllocation'].count() / len(train_t)
t2 = test_t.groupby(['nAllocation'])['nAllocation'].count() / len(test_t)

tmp = pd.concat([t1, t2], axis=1)
tmp.columns = ['train', 'test']
tmp.plot.bar()
plt.xticks(rotation=0)
plt.ylabel('Nombre d''observations')
nalloc1
t1 = train_t.groupby(['nbPartants'])['nbPartants'].count() / len(train_t)
t2 = test_t.groupby(['nbPartants'])['nbPartants'].count() / len(test_t)

tmp = pd.concat([t1, t2], axis=1)
tmp.columns = ['train', 'test']
tmp.plot.bar()
plt.xticks(rotation=0)
plt.ylabel('Nombre d''observations')
nbpartantst

On voit bien que la discrétisation à largeur égale n’améliore pas l’écart de valeur. La variable originale allocation était biaisée, et la variable discrète l’est également.

GCH anime

Je télécharge mon guide gratuit

Vous recevrez votre guide par email sans aucun engagement de votre part.

Si vous voulez découvrir comment fonctionne la librairie pandas ou bien l’environnement Jupyter, n’hésitez pas à consulter les cours ci-dessous.

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.