J'ai un problème de classification en machine learning avec 80% de variables catégorielles. Dois-je utiliser un encodage à chaud si je veux utiliser un classificateur pour la classification? Puis-je transmettre les données à un classificateur sans encodage?

J'essaie de faire ce qui suit pour la sélection des fonctionnalités:

1. J'ai lu le fichier du train:

   num_rows_to_read = 10000
   train_small = pd.read_csv("../../dataset/train.csv",   nrows=num_rows_to_read)

2. Je change le type des caractéristiques catégorielles en 'catégorie':

   non_categorial_features = ['orig_destination_distance',
                             'srch_adults_cnt',
                             'srch_children_cnt',
                             'srch_rm_cnt',
                             'cnt']
   
   for categorical_feature in list(train_small.columns):
       if categorical_feature not in non_categorial_features:
           train_small[categorical_feature] = train_small[categorical_feature].astype('category')

3. J'utilise un encodage à chaud:

   train_small_with_dummies = pd.get_dummies(train_small, sparse=True)

Le problème est que la 3ème partie reste souvent bloquée, même si j'utilise une machine puissante.

Ainsi, sans le seul encodage à chaud, je ne peux pas faire de sélection de fonctionnalités, pour déterminer l'importance des fonctionnalités.

Que recommandez-vous?

Approche 1: Vous pouvez utiliser get_dummies sur le dataframe pandas.

Exemple 1:

import pandas as pd
s = pd.Series(list('abca'))
pd.get_dummies(s)
Out[]: 
     a    b    c
0  1.0  0.0  0.0
1  0.0  1.0  0.0
2  0.0  0.0  1.0
3  1.0  0.0  0.0

Exemple 2:

Ce qui suit transformera une colonne donnée en une colonne chaude. Utilisez le préfixe pour avoir plusieurs mannequins.

import pandas as pd

df = pd.DataFrame({
          'A':['a','b','a'],
          'B':['b','a','c']
        })
df
Out[]: 
   A  B
0  a  b
1  b  a
2  a  c

# Get one hot encoding of columns B
one_hot = pd.get_dummies(df['B'])
# Drop column B as it is now encoded
df = df.drop('B',axis = 1)
# Join the encoded df
df = df.join(one_hot)
df  
Out[]: 
       A  a  b  c
    0  a  0  1  0
    1  b  1  0  0
    2  a  0  0  1

Approche 2: utiliser Scikit-learn

Étant donné un ensemble de données avec trois entités et quatre échantillons, nous laissons l'encodeur trouver la valeur maximale par entité et transformons les données en un encodage binaire one-hot.

>>> from sklearn.preprocessing import OneHotEncoder
>>> enc = OneHotEncoder()
>>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])   
OneHotEncoder(categorical_features='all', dtype=<class 'numpy.float64'>,
   handle_unknown='error', n_values='auto', sparse=True)
>>> enc.n_values_
array([2, 3, 4])
>>> enc.feature_indices_
array([0, 2, 5, 9], dtype=int32)
>>> enc.transform([[0, 1, 1]]).toarray()
array([[ 1.,  0.,  0.,  1.,  0.,  0.,  1.,  0.,  0.]])

Voici le lien pour cet exemple: http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html

Beaucoup plus facile à utiliser Pandas pour l'encodage de base à chaud. Si vous recherchez plus d'options, vous pouvez utiliser scikit-learn.

Pour l'encodage à chaud de base avec Pandas, il vous suffit de passer votre trame de données dans la fonction get_dummies .

Par exemple, si j'ai un dataframe appelé imdb_movies :

... et je veux encoder à chaud la colonne Notée, je fais simplement ceci:

pd.get_dummies(imdb_movies.Rated)

Cela renvoie un nouveau dataframeavec une colonne pour chaque " niveau " de notation qui existe, avec un 1 ou un 0 spécifiant la présence de cette note pour une observation donnée.

Habituellement, nous voulons que cela fasse partie de l'original dataframe. Dans ce cas, nous attachons simplement notre nouveau cadre codé factice sur le cadre d'origine en utilisant " column-binding .

Nous pouvons lier des colonnes à l'aide de la fonction concat de Pandas :

rated_dummies = pd.get_dummies(imdb_movies.Rated)
pd.concat([imdb_movies, rated_dummies], axis=1)

Nous pouvons maintenant exécuter une analyse sur notre pleine dataframe.

FONCTION UTILITAIRE SIMPLE

Je recommanderais de vous créer une fonction utilitaire pour le faire rapidement:

def encode_and_bind(original_dataframe, feature_to_encode):
    dummies = pd.get_dummies(original_dataframe[[feature_to_encode]])
    res = pd.concat([original_dataframe, dummies], axis=1)
    return(res)

Utilisation :

encode_and_bind(imdb_movies, 'Rated')

Résultat :

De plus, selon le commentaire @pmalbu, si vous souhaitez que la fonction supprime le feature_to_encode d'origine, utilisez cette version:

def encode_and_bind(original_dataframe, feature_to_encode):
    dummies = pd.get_dummies(original_dataframe[[feature_to_encode]])
    res = pd.concat([original_dataframe, dummies], axis=1)
    res = res.drop([feature_to_encode], axis=1)
    return(res) 

Vous pouvez encoder plusieurs entités en même temps comme suit:

features_to_encode = ['feature_1', 'feature_2', 'feature_3',
                      'feature_4']
for feature in features_to_encode:
    res = encode_and_bind(train_set, feature)

Vous pouvez le faire avec numpy.eyeet a en utilisant le mécanisme de sélection des éléments du tableau:

import numpy as np
nb_classes = 6
data = [[2, 3, 4, 0]]

def indices_to_one_hot(data, nb_classes):
    """Convert an iterable of indices to one-hot encoded labels."""
    targets = np.array(data).reshape(-1)
    return np.eye(nb_classes)[targets]

La valeur de retour de indices_to_one_hot(nb_classes, data)est maintenant

array([[[ 0.,  0.,  1.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  1.,  0.,  0.],
        [ 0.,  0.,  0.,  0.,  1.,  0.],
        [ 1.,  0.,  0.,  0.,  0.,  0.]]])

Le .reshape(-1)est là pour vous assurer que vous avez le bon format d'étiquettes (vous pourriez aussi avoir [[2], [3], [4], [0]]).

Tout d'abord, le moyen le plus simple de coder à chaud: utilisez Sklearn.

http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html

Deuxièmement, je ne pense pas que l'utilisation de pandas pour un encodage à chaud soit aussi simple (non confirmé cependant)

Création de variables factices dans Pandas pour Python

Enfin, est-il nécessaire de faire un encodage à chaud? Un encodage à chaud augmente de manière exponentielle le nombre de fonctionnalités, augmentant considérablement le temps d'exécution de tout classificateur ou de tout autre élément que vous allez exécuter. Surtout lorsque chaque caractéristique catégorielle a plusieurs niveaux. Au lieu de cela, vous pouvez effectuer un codage factice.

L'utilisation d'un codage factice fonctionne généralement bien, pour beaucoup moins de temps d'exécution et de complexité. Un prof avisé m'a dit un jour: «Moins c'est plus».

Voici le code de ma fonction d'encodage personnalisée si vous le souhaitez.

from sklearn.preprocessing import LabelEncoder

#Auto encodes any dataframe column of type category or object.
def dummyEncode(df):
        columnsToEncode = list(df.select_dtypes(include=['category','object']))
        le = LabelEncoder()
        for feature in columnsToEncode:
            try:
                df[feature] = le.fit_transform(df[feature])
            except:
                print('Error encoding '+feature)
        return df

EDIT: Comparaison pour être plus claire:

Encodage à chaud: convertissez n niveaux en n-1 colonnes.

Index  Animal         Index  cat  mouse
  1     dog             1     0     0
  2     cat       -->   2     1     0
  3    mouse            3     0     1

Vous pouvez voir comment cela fera exploser votre mémoire si vous avez de nombreux types (ou niveaux) différents dans votre fonction catégorielle. Gardez à l'esprit que ce n'est qu'une colonne.

Codage factice:

Index  Animal         Index  Animal
  1     dog             1      0   
  2     cat       -->   2      1 
  3    mouse            3      2

Convertissez plutôt en représentations numériques. Économise considérablement de l'espace sur les fonctionnalités, au prix d'un peu de précision.

Un encodage à chaud avec des pandas est très simple:

def one_hot(df, cols):
    """
    @param df pandas DataFrame
    @param cols a list of columns to encode 
    @return a DataFrame with one-hot encoding
    """
    for each in cols:
        dummies = pd.get_dummies(df[each], prefix=each, drop_first=False)
        df = pd.concat([df, dummies], axis=1)
    return df

ÉDITER:

Une autre façon de one_hot en utilisant sklearn LabelBinarizer:

from sklearn.preprocessing import LabelBinarizer 
label_binarizer = LabelBinarizer()
label_binarizer.fit(all_your_labels_list) # need to be global or remembered to use it later

def one_hot_encode(x):
    """
    One hot encode a list of sample labels. Return a one-hot encoded vector for each label.
    : x: List of sample Labels
    : return: Numpy array of one-hot encoded labels
    """
    return label_binarizer.transform(x)

Vous pouvez utiliser la fonction numpy.eye.

import numpy as np

def one_hot_encode(x, n_classes):
    """
    One hot encode a list of sample labels. Return a one-hot encoded vector for each label.
    : x: List of sample Labels
    : return: Numpy array of one-hot encoded labels
     """
    return np.eye(n_classes)[x]

def main():
    list = [0,1,2,3,4,3,2,1,0]
    n_classes = 5
    one_hot_list = one_hot_encode(list, n_classes)
    print(one_hot_list)

if __name__ == "__main__":
    main()

Résultat

D:\Desktop>python test.py
[[ 1.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  0.  0.  1.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 1.  0.  0.  0.  0.]]

pandas comme a la fonction intégrée "get_dummies" pour obtenir un encodage à chaud de cette colonne / s particulière.

code d'une ligne pour un encodage à chaud:

df=pd.concat([df,pd.get_dummies(df['column name'],prefix='column name')],axis=1).drop(['column name'],axis=1)

Voici une solution utilisant DictVectorizeret la DataFrame.to_dict('records')méthode Pandas .

>>> import pandas as pd
>>> X = pd.DataFrame({'income': [100000,110000,90000,30000,14000,50000],
                      'country':['US', 'CAN', 'US', 'CAN', 'MEX', 'US'],
                      'race':['White', 'Black', 'Latino', 'White', 'White', 'Black']
                     })

>>> from sklearn.feature_extraction import DictVectorizer
>>> v = DictVectorizer()
>>> qualitative_features = ['country','race']
>>> X_qual = v.fit_transform(X[qualitative_features].to_dict('records'))
>>> v.vocabulary_
{'country=CAN': 0,
 'country=MEX': 1,
 'country=US': 2,
 'race=Black': 3,
 'race=Latino': 4,
 'race=White': 5}

>>> X_qual.toarray()
array([[ 0.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  1.,  0.],
       [ 1.,  0.,  0.,  0.,  0.,  1.],
       [ 0.,  1.,  0.,  0.,  0.,  1.],
       [ 0.,  0.,  1.,  1.,  0.,  0.]])

Le codage à chaud nécessite un peu plus que la conversion des valeurs en variables indicatrices. En règle générale, le processus de ML vous oblige à appliquer ce codage plusieurs fois à des ensembles de données de validation ou de test et à appliquer le modèle que vous construisez à des données observées en temps réel. Vous devez stocker le mappage (transformation) qui a été utilisé pour construire le modèle. Une bonne solution utiliserait le DictVectorizerou LabelEncoder(suivi de get_dummies. Voici une fonction que vous pouvez utiliser:

def oneHotEncode2(df, le_dict = {}):
    if not le_dict:
        columnsToEncode = list(df.select_dtypes(include=['category','object']))
        train = True;
    else:
        columnsToEncode = le_dict.keys()   
        train = False;

    for feature in columnsToEncode:
        if train:
            le_dict[feature] = LabelEncoder()
        try:
            if train:
                df[feature] = le_dict[feature].fit_transform(df[feature])
            else:
                df[feature] = le_dict[feature].transform(df[feature])

            df = pd.concat([df, 
                              pd.get_dummies(df[feature]).rename(columns=lambda x: feature + '_' + str(x))], axis=1)
            df = df.drop(feature, axis=1)
        except:
            print('Error encoding '+feature)
            #df[feature]  = df[feature].convert_objects(convert_numeric='force')
            df[feature]  = df[feature].apply(pd.to_numeric, errors='coerce')
    return (df, le_dict)

Cela fonctionne sur une trame de données pandas et pour chaque colonne de la trame de données, il crée et renvoie un mappage. Donc, vous l'appelleriez comme ceci:

train_data, le_dict = oneHotEncode2(train_data)

Puis sur les données de test, l'appel se fait en passant le dictionnaire renvoyé par l'entraînement:

test_data, _ = oneHotEncode2(test_data, le_dict)

Une méthode équivalente consiste à utiliser DictVectorizer. Un article connexe sur le même est sur mon blog. Je le mentionne ici car il fournit un raisonnement derrière cette approche sur l'utilisation simple du post get_dummies (divulgation: c'est mon propre blog).

Vous pouvez transmettre les données au classificateur catboost sans codage. Catboost gère lui-même les variables catégorielles en effectuant un codage de moyenne expansible one-hot et target.

Vous pouvez également effectuer les opérations suivantes. Remarque pour ce qui suit, vous ne devez pas utiliser pd.concat.

import pandas as pd 
# intialise data of lists. 
data = {'Color':['Red', 'Yellow', 'Red', 'Yellow'], 'Length':[20.1, 21.1, 19.1, 18.1],
       'Group':[1,2,1,2]} 

# Create DataFrame 
df = pd.DataFrame(data) 

for _c in df.select_dtypes(include=['object']).columns:
    print(_c)
    df[_c]  = pd.Categorical(df[_c])
df_transformed = pd.get_dummies(df)
df_transformed

Vous pouvez également remplacer les colonnes explicites par catégorielles. Par exemple, ici je change le ColoretGroup

import pandas as pd 
# intialise data of lists. 
data = {'Color':['Red', 'Yellow', 'Red', 'Yellow'], 'Length':[20.1, 21.1, 19.1, 18.1],
       'Group':[1,2,1,2]} 

# Create DataFrame 
df = pd.DataFrame(data) 
columns_to_change = list(df.select_dtypes(include=['object']).columns)
columns_to_change.append('Group')
for _c in columns_to_change:
    print(_c)
    df[_c]  = pd.Categorical(df[_c])
df_transformed = pd.get_dummies(df)
df_transformed

Je sais que je suis en retard à cette fête, mais le moyen le plus simple d'encoder à chaud une trame de données de manière automatisée est d'utiliser cette fonction:

def hot_encode(df):
    obj_df = df.select_dtypes(include=['object'])
    return pd.get_dummies(df, columns=obj_df.columns).values

J'ai utilisé ceci dans mon modèle acoustique: cela aide probablement dans votre modèle.

def one_hot_encoding(x, n_out):
    x = x.astype(int)  
    shape = x.shape
    x = x.flatten()
    N = len(x)
    x_categ = np.zeros((N,n_out))
    x_categ[np.arange(N), x] = 1
    return x_categ.reshape((shape)+(n_out,))

Pour ajouter à d'autres questions, laissez-moi vous expliquer comment je l'ai fait avec une fonction Python 2.0 utilisant Numpy:

def one_hot(y_):
    # Function to encode output labels from number indexes 
    # e.g.: [[5], [0], [3]] --> [[0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]]

    y_ = y_.reshape(len(y_))
    n_values = np.max(y_) + 1
    return np.eye(n_values)[np.array(y_, dtype=np.int32)]  # Returns FLOATS

La ligne n_values = np.max(y_) + 1pourrait être codée en dur pour que vous utilisiez le bon nombre de neurones au cas où vous utiliseriez des mini-lots par exemple.

Projet de démonstration / tutoriel où cette fonction a été utilisée: https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition

Cela fonctionne pour moi:

pandas.factorize( ['B', 'C', 'D', 'B'] )[0]

Production:

[0, 1, 2, 0]

Cela peut et devrait être aussi simple que:

class OneHotEncoder:
    def __init__(self,optionKeys):
        length=len(optionKeys)
        self.__dict__={optionKeys[j]:[0 if i!=j else 1 for i in range(length)] for j in range(length)}

Utilisation:

ohe=OneHotEncoder(["A","B","C","D"])
print(ohe.A)
print(ohe.D)

Élargir la réponse de @Martin Thoma

def one_hot_encode(y):
    """Convert an iterable of indices to one-hot encoded labels."""
    y = y.flatten() # Sometimes not flattened vector is passed e.g (118,1) in these cases
    # the function ends up creating a tensor e.g. (118, 2, 1). flatten removes this issue
    nb_classes = len(np.unique(y)) # get the number of unique classes
    standardised_labels = dict(zip(np.unique(y), np.arange(nb_classes))) # get the class labels as a dictionary
    # which then is standardised. E.g imagine class labels are (4,7,9) if a vector of y containing 4,7 and 9 is
    # directly passed then np.eye(nb_classes)[4] or 7,9 throws an out of index error.
    # standardised labels fixes this issue by returning a dictionary;
    # standardised_labels = {4:0, 7:1, 9:2}. The values of the dictionary are mapped to keys in y array.
    # standardised_labels also removes the error that is raised if the labels are floats. E.g. 1.0; element
    # cannot be called by an integer index e.g y[1.0] - throws an index error.
    targets = np.vectorize(standardised_labels.get)(y) # map the dictionary values to array.
    return np.eye(nb_classes)[targets]

Réponse courte

Voici une fonction pour effectuer un encodage à chaud sans utiliser numpy, pandas ou autres packages. Il prend une liste d'entiers, de booléens ou de chaînes (et peut-être d'autres types aussi).

import typing


def one_hot_encode(items: list) -> typing.List[list]:
    results = []
    # find the unique items (we want to unique items b/c duplicate items will have the same encoding)
    unique_items = list(set(items))
    # sort the unique items
    sorted_items = sorted(unique_items)
    # find how long the list of each item should be
    max_index = len(unique_items)

    for item in items:
        # create a list of zeros the appropriate length
        one_hot_encoded_result = [0 for i in range(0, max_index)]
        # find the index of the item
        one_hot_index = sorted_items.index(item)
        # change the zero at the index from the previous line to a one
        one_hot_encoded_result[one_hot_index] = 1
        # add the result
        results.append(one_hot_encoded_result)

    return results

Exemple:

one_hot_encode([2, 1, 1, 2, 5, 3])

# [[0, 1, 0, 0],
#  [1, 0, 0, 0],
#  [1, 0, 0, 0],
#  [0, 1, 0, 0],
#  [0, 0, 0, 1],
#  [0, 0, 1, 0]]

one_hot_encode([True, False, True])

# [[0, 1], [1, 0], [0, 1]]

one_hot_encode(['a', 'b', 'c', 'a', 'e'])

# [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [1, 0, 0, 0], [0, 0, 0, 1]]

Réponse longue (er)

Je sais qu'il y a déjà beaucoup de réponses à cette question, mais j'ai remarqué deux choses. Premièrement, la plupart des réponses utilisent des packages comme numpy et / ou pandas. Et c'est une bonne chose. Si vous écrivez du code de production, vous devriez probablement utiliser des algorithmes robustes et rapides comme ceux fournis dans les packages numpy / pandas. Mais, dans un souci d'éducation, je pense que quelqu'un devrait fournir une réponse qui a un algorithme transparent et pas seulement une implémentation de l'algorithme de quelqu'un d'autre. Deuxièmement, j'ai remarqué que de nombreuses réponses ne fournissent pas une implémentation robuste de l'encodage à chaud car elles ne répondent pas à l'une des exigences ci-dessous. Voici quelques-unes des exigences (telles que je les vois) pour une fonction d'encodage à chaud utile, précise et robuste:

Une fonction d'encodage à chaud doit:

• gérer une liste de différents types (par exemple des entiers, des chaînes, des flottants, etc.) en entrée
• gérer une liste d'entrée avec des doublons
• retourne une liste de listes correspondant (dans le même ordre que) aux entrées
• retourne une liste de listes où chaque liste est la plus courte possible

J'ai testé de nombreuses réponses à cette question et la plupart d'entre elles échouent à l'une des exigences ci-dessus.

Essaye ça:

!pip install category_encoders
import category_encoders as ce

categorical_columns = [...the list of names of the columns you want to one-hot-encode ...]
encoder = ce.OneHotEncoder(cols=categorical_columns, use_cat_names=True)
df_train_encoded = encoder.fit_transform(df_train_small)

df_encoded.head ()

La trame de données résultante df_train_encodedest la même que l'original, mais les fonctionnalités catégorielles sont désormais remplacées par leurs versions encodées à chaud.

Plus d'informations category_encoders ici .

Ici, j'ai essayé avec cette approche:

import numpy as np
#converting to one_hot





def one_hot_encoder(value, datal):

    datal[value] = 1

    return datal


def _one_hot_values(labels_data):
    encoded = [0] * len(labels_data)

    for j, i in enumerate(labels_data):
        max_value = [0] * (np.max(labels_data) + 1)

        encoded[j] = one_hot_encoder(i, max_value)

    return np.array(encoded)