Ho un problema di classificazione dell'apprendimento automatico con variabili categoriche dell'80%. Devo usare una codifica a caldo se voglio usare un classificatore per la classificazione? Posso passare i dati a un classificatore senza la codifica?

Sto provando a fare quanto segue per la selezione delle funzionalità:

1. Ho letto il file del treno:

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

2. Cambio il tipo di caratteristiche categoriche in "categoria":

   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. Uso una codifica a caldo:

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

Il problema è che la terza parte si blocca spesso, anche se sto usando una macchina forte.

Pertanto, senza l'unica codifica a caldo non posso fare alcuna selezione di funzionalità, per determinare l'importanza delle funzionalità.

Che cosa mi consiglia?

Approccio 1: è possibile utilizzare get_dummies sul frame di dati Panda.

Esempio 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

Esempio 2:

Quanto segue trasformerà una determinata colonna in una hot. Usa il prefisso per avere più manichini.

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

Approccio 2: utilizzare Scikit-learn

Dato un set di dati con tre funzionalità e quattro esempi, lasciamo che l'encoder trovi il valore massimo per funzione e trasformi i dati in una codifica binaria a una sola opzione.

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

Ecco il link per questo esempio: http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html

Panda molto più facili da usare per la codifica one-hot di base. Se stai cercando più opzioni puoi usare scikit-learn.

Per la codifica one-hot di base con Pandas, è sufficiente passare il frame di dati nella funzione get_dummies .

Ad esempio, se ho un frame di dati chiamato imdb_movies :

... e voglio codificare a caldo la colonna nominale, semplicemente faccio questo:

pd.get_dummies(imdb_movies.Rated)

Questo restituisce un nuovo dataframecon una colonna per ogni " livello " di valutazione esistente, insieme a 1 o 0 che specifica la presenza di quella valutazione per una data osservazione.

Di solito, vogliamo che questo sia parte dell'originale dataframe. In questo caso, colleghiamo semplicemente la nostra nuova cornice codificata fittizia alla cornice originale usando " rilegatura a colonna .

Possiamo legare le colonne usando la funzione concat di Pandas :

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

Ora possiamo eseguire un'analisi completa dataframe.

FUNZIONE UTILITY SEMPLICE

Ti consiglierei di farti una funzione di utilità per farlo rapidamente:

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)

Utilizzo :

encode_and_bind(imdb_movies, 'Rated')

Risultato :

Inoltre, come per il commento di @pmalbu, se si desidera che la funzione rimuova il feature_to_encode originale, utilizzare questa versione:

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) 

Puoi codificare più funzionalità contemporaneamente come segue:

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

Puoi farlo con numpy.eyee usando il meccanismo di selezione degli elementi dell'array:

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]

Il valore restituito di indices_to_one_hot(nb_classes, data)è ora

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)è lì per assicurarsi di avere il formato etichette destra (si potrebbe anche avere [[2], [3], [4], [0]]).

In primo luogo, il modo più semplice per una codifica a caldo: usa Sklearn.

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

In secondo luogo, non penso che usare i panda per una codifica a caldo sia così semplice (non confermato)

Creazione di variabili fittizie in panda per Python

Infine, è necessario per te una codifica a caldo? Una codifica a caldo aumenta in modo esponenziale il numero di funzionalità, aumentando drasticamente il tempo di esecuzione di qualsiasi classificatore o qualsiasi altra cosa che stai per eseguire. Soprattutto quando ogni caratteristica categoriale ha molti livelli. Invece puoi fare codici fittizi.

L'uso della codifica fittizia di solito funziona bene, con tempi di esecuzione e complessità molto inferiori. Un prof saggio una volta mi disse: "Less is More".

Ecco il codice per la mia funzione di codifica personalizzata, se lo desideri.

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: confronto per essere più chiaro:

Codifica one-hot: converti n livelli in n-1 colonne.

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

Puoi vedere come questo esploderà la tua memoria se hai molti tipi (o livelli) diversi nella tua caratteristica categoriale. Ricorda, questa è solo UNA colonna.

Codifica fittizia:

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

Converti invece in rappresentazioni numeriche. Risparmia notevolmente lo spazio delle funzionalità, al costo di un po 'di precisione.

Una codifica a caldo con i panda è molto semplice:

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

MODIFICARE:

Un altro modo per one_hot usando 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)

È possibile utilizzare la funzione 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()

Risultato

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

Panda as ha la funzione integrata "get_dummies" per ottenere una codifica a caldo di quella particolare colonna / e.

un codice di riga per una codifica a caldo:

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

Ecco una soluzione che utilizza DictVectorizere il DataFrame.to_dict('records')metodo 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.]])

La codifica one-hot richiede qualcosa in più rispetto alla conversione dei valori in variabili indicatore. In genere il processo ML richiede di applicare questa codifica più volte alla convalida o al test di insiemi di dati e all'applicazione del modello costruito ai dati osservati in tempo reale. È necessario archiviare la mappatura (trasformazione) utilizzata per costruire il modello. Una buona soluzione dovrebbe usare DictVectorizero LabelEncoder(seguita da get_dummies. Ecco una funzione che puoi usare:

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)

Funziona su un frame di dati Panda e per ogni colonna del frame di dati crea e restituisce una mappatura indietro. Quindi lo chiameresti così:

train_data, le_dict = oneHotEncode2(train_data)

Quindi sui dati del test, la chiamata viene effettuata passando il dizionario restituito dall'allenamento:

test_data, _ = oneHotEncode2(test_data, le_dict)

Un metodo equivalente è quello di utilizzare DictVectorizer. Un post correlato sullo stesso è sul mio blog. Lo cito qui poiché fornisce alcuni ragionamenti alla base di questo approccio sul semplice utilizzo del post get_dummies (divulgazione: questo è il mio blog).

È possibile passare i dati al classificatore catboost senza codifica. Catboost gestisce le variabili categoriali stesse eseguendo la codifica media a caldo e in espansione target.

Puoi anche fare quanto segue. Nota per il seguito non è necessario utilizzare 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

Puoi anche modificare le colonne esplicite in categoriali. Ad esempio, qui sto cambiando il ColoreGroup

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

So di essere in ritardo per questa festa, ma il modo più semplice per codificare a caldo un frame di dati in modo automatizzato è utilizzare questa funzione:

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

L'ho usato nel mio modello acustico: probabilmente questo aiuta nel tuo modello.

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

Per aggiungere ad altre domande, lasciami fornire come ho fatto con una funzione Python 2.0 usando 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 linea n_values = np.max(y_) + 1potrebbe essere hardcoded per poter utilizzare il buon numero di neuroni nel caso in cui si utilizzino mini-batch ad esempio.

Progetto / tutorial dimostrativo in cui è stata utilizzata questa funzione: https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition

Questo funziona per me:

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

Produzione:

[0, 1, 2, 0]

Può e dovrebbe essere facile come:

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

Utilizzo:

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

Espandendo la risposta di @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]

Risposta breve

Ecco una funzione per eseguire la codifica one-hot senza usare numpy, panda o altri pacchetti. Prende un elenco di numeri interi, booleani o stringhe (e forse anche altri tipi).

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

Esempio:

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

Risposta lunga (er)

So che ci sono già molte risposte a questa domanda, ma ho notato due cose. Innanzitutto, la maggior parte delle risposte utilizza pacchetti come numpy e / o panda. E questa è una buona cosa. Se stai scrivendo un codice di produzione, dovresti probabilmente usare algoritmi robusti e veloci come quelli forniti nei pacchetti numpy / pandas. Ma, per motivi di educazione, penso che qualcuno dovrebbe fornire una risposta che abbia un algoritmo trasparente e non solo un'implementazione dell'algoritmo di qualcun altro. In secondo luogo, ho notato che molte delle risposte non forniscono un'implementazione robusta della codifica one-hot perché non soddisfano uno dei requisiti di seguito. Di seguito sono riportati alcuni dei requisiti (come li vedo io) per una funzione di codifica one-hot utile, accurata e robusta:

Una funzione di codifica one-hot deve:

• gestire un elenco di vari tipi (es. numeri interi, stringhe, float, ecc.) come input
• gestire un elenco di input con duplicati
• restituisce un elenco di elenchi corrispondenti (nello stesso ordine di) agli input
• restituisce un elenco di elenchi in cui ciascun elenco è il più breve possibile

Ho testato molte delle risposte a questa domanda e la maggior parte di esse non soddisfa uno dei requisiti di cui sopra.

Prova questo:

!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 ()

Il dataframe risultante df_train_encodedè lo stesso dell'originale, ma le caratteristiche categoriali sono ora sostituite con le loro versioni con codifica a caldo.

Maggiori informazioni category_encoders qui .

Qui ho provato con questo approccio:

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)