Un encodage à chaud, consiste à coder chaque variable catégorielle avec différentes variables booléennes (aussi appelées variables factices) qui prennent les valeurs 0 ou 1, indiquant si une catégorie est présente dans une observation.
Par exemple, pour la variable catégorielle “Sexe”, avec les étiquettes “femme” et “mâle”, nous pouvons générer la variable booléenne “femme”, qui prend la valeur 1 si la personne est “femme” ou 0 sinon, ou nous pouvons générer la variable “mâle”, qui prend la valeur 1 si la personne est “mâle” et 0 sinon.
Pour la variable catégorielle “couleur” avec les valeurs “rouge”, “bleu” et “vert”, nous pouvons créer 3 nouvelles variables appelées “rouge”, “bleu” et “vert”. Ces variables prendront la valeur 1, si l’observation est de ladite couleur ou 0 sinon.
Encodage en k-1 variables factices
Notez cependant que pour la variable “color”, en créant 2 variables binaires, disons “rouge” et “bleu”, nous encodons déjà Toutes les informations :
- si l’observation est rouge, elle sera saisie par la variable “rouge” (rouge = 1, bleu = 0)
- si l’observation est bleue, elle sera saisie par la variable “bleu” (rouge = 0, bleu = 1)
- si l’observation est verte, elle sera saisie par la combinaison de “rouge” et “bleu” (rouge = 0, bleu = 0)
Nous n’avons pas besoin d’ajouter une troisième variable “verte” pour indiquer que l’observation est verte.
Plus généralement, une variable catégorielle doit être encodée en créant k-1 variables binaires, où k est le nombre de catégories distinctes. Dans le cas du sexe, k=2 (homme / femme), nous devons donc créer seulement 1 (k – 1 = 1) variable binaire. Dans le cas de la couleur, qui a 3 catégories différentes (k=3), nous devons créer 2 (k – 1 = 2) variables binaires pour saisir toutes les informations.
Un codage à chaud en k-1 variables binaires tient compte du fait que nous pouvons utiliser 1 dimension de moins et représenter quand même toute l’information : si l’observation est 0 dans toutes les variables binaires, alors elle doit être 1 dans la variable binaire finale (non présente).
Lors d’un encodage à chaud des variables catégorielles, nous créons k – 1 variables binaires
La plupart des algorithmes d’apprentissage automatique prennent en compte l’ensemble des données tout en étant adaptés. Il est donc préférable de coder les variables catégorielles en k – 1 variables binaires, car cela évite d’introduire des informations redondantes.
Exception : Un codage à chaud en k variables fictives
Il est parfois préférable de coder les variables en k variables factices :
- lors de la construction d’algorithmes basés sur des arbres
- lors de la sélection de caractéristiques par des algorithmes récursifs
- lorsqu’il s’agit de déterminer l’importance de chaque catégorie
Les algorithmes basés sur l’arbre, contrairement à la majorité des algorithmes d’apprentissage machine, n’évaluent pas l’ensemble des données pendant la formation. Ils extraient aléatoirement un sous-ensemble de caractéristiques de l’ensemble de données à chaque nœud de chaque arbre. Par conséquent, si nous voulons qu’un algorithme basé sur l’arbre prenne en compte toute les catégories, nous devons coder les variables catégorielles en k variables binaires.
Si nous prévoyons de sélectionner des caractéristiques par élimination (ou addition) récursive, ou si nous voulons évaluer l’importance de chaque catégorie de la variable catégorielle, alors nous aurons également besoin de l’ensemble des variables binaires (k) pour permettre au modèle d’apprentissage machine de sélectionner celles qui ont le plus de pouvoir prédictif.
Avantages d’un encodage à chaud
- Simple à mettre en œuvre
- Ne fait aucune hypothèse sur la distribution ou les catégories de la variable catégorielle
- Conserve toutes les informations de la variable catégorielle
- Convient aux modèles linéaires
Limitations
- Élargir l’espace de présentation
- N’ajoute pas d’informations supplémentaires lors de l’encodage
- De nombreuses variables factices peuvent être identiques, ce qui introduit des informations redondantes
Notes
Si nos jeux de données contiennent quelques variables hautement cardinales, nous nous retrouverons très bientôt avec des jeux de données comportant des milliers de colonnes, ce qui pourrait rendre l’apprentissage de nos algorithmes lent et l’interprétation des modèles difficile.
En outre, nombre de ces variables fictives peuvent être similaires les unes aux autres, car il n’est pas rare que deux ou plusieurs variables partagent les mêmes combinaisons de 1 et de 0. Par conséquent, un encodage à chaud peut introduire des informations redondantes ou dupliquées même si nous codons en k-1.
Dans cette démo :
Nous allons voir comment effectuer un encodage à chaud avec :
- pandas
- Scikit-learn
- Feature-Engine
Et les avantages et les limites de chaque mise en œuvre.
Encodage important
Tout comme l’imputation, toutes les méthodes de codage catégoriel doivent être effectuées sur l’ensemble de formation, puis propagées à l’ensemble de test.
Pourquoi ?
Parce que ces méthodes “apprendront” des modèles à partir des données du train, et que vous voulez donc éviter les fuites d’informations et le surajustement. Mais surtout, parce que nous ne savons pas si, à l’avenir / dans les données en direct, toutes les catégories seront présentes dans les données d’entraienemnt, ou s’il y aura plus ou moins de catégories. Nous voulons donc anticiper cette incertitude en mettant en place les bons processus dès le départ.
Explorons la cardinalité
Comme nous le savons déjà, nous avons beaucoup de cardinalités. Dans un notebook précédant sur l’analyse des étiquettes rares, nous avons vu une technique pour diminuer les cardinalités en les regroupant.
Un encodage à chaud avec pandas
Avantages
- rapide
- retourne un dataframe pandas
- renvoie les noms des caractéristiques pour les variables factices
Limites des pandas :
- elle ne préserve pas les informations des données d’entrainement pour les propager aux données de test
La méthode pandas get_dummies(), créera autant de variables binaires que de catégories dans la variable :
Si la couleur de la variable a 3 catégories dans les données du train, elle créera 2 variables factices. Cependant, si la couleur de la variable a 5 catégories dans les données de test, elle créera 4 variables binaires. Par conséquent, les ensembles de train et de test se retrouveront avec un nombre différent de caractéristiques et seront incompatibles avec la formation et la notation à l’aide de Scikit-learn.
Dans la pratique, nous ne devrions pas utiliser de “get-dummies” dans nos pipelines d’apprentissage machine. Il est cependant utile, pour une exploration rapide des données. Voyons cela à l’aide d’exemples.
Un encodage à chaud avec Scikit-learn
Avantages
- rapide
- Crée le même nombre de fonctions dans le train et le banc d’essai
Limitations
- il renvoie un tableau numérique au lieu d’une trame de données de pandas
- il ne renvoie pas les noms des variables, ce qui est peu pratique pour l’exploration des variables
Nous pouvons voir que train et test contiennent le même nombre de caractéristiques.
Vous trouverez plus de détails sur OneHotEncoder de Scikit-learn à l’adresse suivante : https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html.
Un encodage à chaud avec Feature-Engine
Avantages
- rapide
- renvoie une trame de données
- renvoie des noms de caractéristiques
- permet de sélectionner les caractéristiques à encoder
Limitations
- Pas encore sûr.
Notez comment le moteur retourne les variables factices avec leurs noms, et laisse tomber la variable originale, laissant l’ensemble de données prêt pour une exploration plus approfondie ou la construction de modèles d’apprentissage machine.
L’avantage d’utiliser Feature-Engine c’est que vous aurez tjs un encodage correct.