У мене є проблема класифікації машинного навчання з 80% категоричними змінними. Чи потрібно використовувати одне гаряче кодування, якщо я хочу використовувати якийсь класифікатор для класифікації? Чи можу я передати дані класифікатору без кодування?

Я намагаюся зробити наступне для вибору функції:

1. Я читаю файл поїзда:

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

2. Я змінюю тип категоричних ознак на "категорію":

   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. Я використовую одне гаряче кодування:

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

Проблема полягає в тому, що 3-я частина часто застрягає, хоча я використовую сильну машину.

Таким чином, без одного гарячого кодування я не можу зробити жодного вибору функцій для визначення важливості функцій.

Що ви порадите?

Підхід 1: Ви можете використовувати get_dummies на пандах даних.

Приклад 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

Приклад 2:

Далі перетворять заданий стовпець в один гарячий. Використовуйте префікс, щоб мати кілька манекенів.

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

Підхід 2: Використовуйте Scikit-learn

Враховуючи набір даних із трьома функціями та чотирма зразками, ми дозволяємо кодеру знайти максимальне значення на одну функцію та перетворимо дані у бінарне однокоткове кодування.

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

Ось посилання на цей приклад: http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html

Набагато простіше використовувати Pandas для базового однокольорового кодування. Якщо ви шукаєте більше варіантів, якими можете скористатися scikit-learn.

Для базового однокольорового кодування з Pandas ви просто передаєте свій кадр даних у функцію get_dummies .

Наприклад, якщо у мене є фрейм даних, який називається imdb_movies :

... і я хочу однозначно кодувати стовпець "Оцінений", я просто роблю це:

pd.get_dummies(imdb_movies.Rated)

Це повертає нове dataframeзі стовпцем для кожного " рівня " рейтингу, який існує, а також 1 або 0, що визначає наявність цього рейтингу для даного спостереження.

Зазвичай ми хочемо, щоб це було частиною оригіналу dataframe. У цьому випадку ми просто прикріплюємо наш новий кодовий макетний кадр до оригінального кадру за допомогою " прив'язки стовпців " .

Ми можемо прив’язувати стовпці за допомогою функції Pandas concat :

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

Тепер ми можемо провести аналіз на повному обсязі dataframe.

ПРОСТА ФУНКЦІЯ УТИЛІТА

Я рекомендую зробити собі функцію утиліти, щоб зробити це швидко:

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)

Використання :

encode_and_bind(imdb_movies, 'Rated')

Результат :

Крім того, згідно з коментарем @pmalbu, якщо ви хочете, щоб функція вилучила оригінальний код_іменного_кода, використовуйте цю версію:

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) 

Ви можете кодувати кілька функцій одночасно:

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

Ви можете це зробити numpy.eyeі за допомогою механізму вибору елементів масиву:

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]

Значення повернення indices_to_one_hot(nb_classes, data)зараз

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

.reshape(-1)Там , щоб переконатися , що ви маєте право формат етикетки (можливо , також є [[2], [3], [4], [0]]).

По-перше, найпростіший спосіб отримати один гарячий кодер: використовувати Sklearn.

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

По-друге, я не думаю, що використання панд для одного гарячого кодування є простим (хоча це не підтверджено)

Створення фіктивних змінних в пандах для python

Нарешті, чи потрібно вам один гарячий кодер? Одне гаряче кодування експоненціально збільшує кількість функцій, різко збільшуючи час роботи будь-якого класифікатора чи будь-чого іншого, що ви збираєтеся запустити. Особливо, коли кожна категорична особливість має багато рівнів. Натомість ви можете робити фіктивне кодування.

Використання фіктивного кодування зазвичай працює добре, за значно менший час та складність. Мудрий проф одного разу сказав мені: «Менше - більше».

Ось код для моєї спеціальної функції кодування, якщо ви хочете.

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: Порівняння буде зрозумілішим:

Одно гаряче кодування: конвертувати n рівнів у n-1 стовпців.

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

Ви можете бачити, як це підірве вашу пам'ять, якщо у вашій категоричній функції є багато різних типів (або рівнів). Майте на увазі, це лише ОДНА стовпець.

Кодування манекена:

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

Перетворіть натомість числові подання. Значно економить простір, ціною трохи точності.

Одне гаряче кодування за допомогою панд дуже просто:

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

Редагувати:

Ще один спосіб one_hot за допомогою 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)

Можна використовувати функцію 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()

Результат

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 має вбудовану функцію "get_dummies", щоб отримати одне гаряче кодування саме цього стовпця / с.

один код рядка для гарячого кодування:

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

Ось рішення з використанням методу DictVectorizerПандаса DataFrame.to_dict('records').

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

Кодування з гарячим кодом вимагає трохи більше, ніж перетворення значень в індикаторні змінні. Зазвичай процес ML вимагає від вас кілька разів застосувати це кодування до валідації чи тестових наборів даних та застосувати модель, яку ви побудуєте, до спостережуваних даних у реальному часі. Ви повинні зберігати відображення (перетворення), яке було використано для побудови моделі. Хорошим рішенням буде використання DictVectorizerабо LabelEncoder(з наступним get_dummies. Ось функція, яку ви можете використовувати:

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)

Це працює на панелі даних панди і для кожного стовпця фрейму даних він створює і повертає відображення назад. Тож ви б назвали це так:

train_data, le_dict = oneHotEncode2(train_data)

Потім за тестовими даними, дзвінок здійснюється шляхом передачі словника, повернутого назад із навчання:

test_data, _ = oneHotEncode2(test_data, le_dict)

Еквівалентним методом є використання DictVectorizer. Пов’язаний пост на тому самому є у моєму блозі. Я згадую це тут, оскільки він дає певні міркування щодо такого підходу щодо просто використання публікації get_dummies (розкриття: це мій власний блог).

Ви можете передати дані в класифікатор catboost без кодування. Catboost обробляє категоричні змінні сам, виконуючи однокоткове та кодове розширення середнього кодування.

Ви також можете зробити наступне. Зверніть увагу на наведене нижче, вам не потрібно користуватися 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

Ви також можете змінити явні стовпці на категоричні. Наприклад, тут я змінюю ColorіGroup

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

Я знаю, що я спізнююся з цією партією, але найпростіший спосіб гарячого кодування фрейму даних автоматизованим способом - це використання цієї функції:

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

Я використовував це в своїй акустичній моделі: можливо, це допомагає в ур-моделі.

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

Щоб додати інші запитання, дозвольте мені пояснити, як я це зробив за допомогою функції Python 2.0 за допомогою 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

Лінія n_values = np.max(y_) + 1може бути важко кодованою, щоб ви використовували велику кількість нейронів, якщо, наприклад, використовуєте міні-партії.

Демонстраційний проект / посібник, де використовується ця функція: https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition

Це працює для мене:

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

Вихід:

[0, 1, 2, 0]

Це може бути і просто, як:

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

Використання:

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

Розширення відповіді @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]

Коротка відповідь

Ось функція робити однокольорове кодування без використання numpy, pandas або інших пакетів. Він містить список цілих чисел, булевих рядків або рядків (і, можливо, також інших типів).

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

Приклад:

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

Довгий (ер) відповідь

Я знаю, що відповідей на це питання вже багато, але я помітив дві речі. По-перше, більшість відповідей використовують такі пакети, як numpy та / або панди. І це гарна річ. Якщо ви пишете виробничий код, вам, ймовірно, слід користуватися надійними, швидкими алгоритмами, такими, які надаються в пакетах numpy / pandas. Але, заради освіти, я думаю, що хтось повинен надати відповідь, яка має прозорий алгоритм, а не просто реалізацію чужого алгоритму. По-друге, я зауважив, що багато відповідей не забезпечують надійної реалізації однокольорового кодування, оскільки вони не відповідають одній із наведених нижче вимог. Нижче наведено деякі вимоги (як я бачу) щодо корисної, точної та надійної функції гарячого кодування:

Функція кодування з гарячим режимом повинна:

• обробляти список різних типів (наприклад, цілі числа, рядки, поплавці тощо) як вхідні дані
• обробляти список введення дублікатами
• повернути список списків, що відповідають (у тому ж порядку, що і) вхідним запитам
• повернути список списків, де кожен список є якомога коротшим

Я перевірив багато відповідей на це запитання, і більшість з них не відповідають одній із вимог, що вказані вище.

Спробуйте це:

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

Отриманий фрейм даних df_train_encoded такий самий, як і оригінальний, але категоричні ознаки тепер замінені на їхні версії, що кодуються гарячими.

Більше інформації category_encoders тут .

Ось я спробував з таким підходом:

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)