Comment puis-je une chaude coder en Python?

Question

J'ai une machine learning problème de classement avec 80% de variables catégorielles. Dois-je utiliser un encodage si je veux utiliser certains classificateur pour le classement? Puis-je transmettre les données à un classificateur sans l'encodage?

Je suis en train de faire les suivants pour la sélection des fonctionnalités:

1. J'ai lu le train de fichier:

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

2. J'ai changer le type de la catégorique fonctionnalités de "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 hot d'encodage:

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

Le problème est que le 3'rd partie souvent coincé, même si je suis à l'aide d'un fort de la machine.

Ainsi, sans que l'une chaude, l'encodage je ne peux faire aucune fonction de sélection, pour la détermination de l'importance des fonctions.

Que recommandez-vous?

Answer 1

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

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:

La suite permettra de transformer une colonne donnée dans un chaud. Utiliser le préfixe d'avoir plusieurs mannequins.

Méthode 2: Utiliser Scikit-learn

Étant donné un ensemble de données avec trois caractéristiques et les quatre échantillons, nous laissons le codeur trouver la valeur maximale par fonctionnalité et de transformer les données d'un fichier binaire "one-hot" de l'encodage.

>>> 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

Answer 2

Vous pouvez le faire avec l' numpy.eye et un à l'aide de l'élément de tableau de mécanisme de sélection:

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 d' 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.]]])

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

Answer 3

Un hot d'encodage avec les pandas est très facile:

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

EDIT:

Une autre façon de one_hot à l'aide de sklearn de l' 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)

Answer 4

Tout d'abord, de la façon la plus simple pour un chaud encoder: utilisation Sklearn.

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

Deuxièmement, je ne pense pas que l'aide de pandas à un hot encoder est simple (non confirmées)

Création de variables muettes dans les pandas pour python

Enfin, est-il nécessaire pour vous d'un hot encoder? Une chaude de codage augmente de façon exponentielle le nombre de fonctionnalités, d'accroître considérablement le temps d'exécution d'un classificateur ou d'autre chose, vous allez exécuter. Surtout quand chaque catégorique fonctionnalité a plusieurs niveaux. Au lieu de cela, vous pouvez faire mannequin de codage.

À l'aide de mannequin encodage fonctionne généralement bien, pour beaucoup moins de temps et de complexité. Un sage prof m'a dit une fois, "Moins est Plus".

Voici le code de mon codage personnalisé fonction 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: la Comparaison, pour être plus clair:

"One-hot" encoding: convertir des niveaux de n à 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 va exploser votre mémoire si vous avez beaucoup de différents types (ou niveaux) dans votre catégorique fonctionnalité. Gardez à l'esprit, c'est juste UNE colonne.

Dummy Coding:

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

Convertir de représentations numériques à la place. Grandement économise de l'espace de la fonctionnalité, au prix d'un peu de précision.

Answer 5

Vous pouvez utiliser numpy.les yeux de la fonction.

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.]]