16中Python機器學習類別特征處理方法總結

類別型特征（categorical feature）主要是指職業，血型等在有限類別內取值的特征。它的原始輸入通常是字符串形式，大多數算法模型不接受數值型特征的輸入，針對數值型的類別特征會被當成數值型特征，從而造成訓練的模型產生錯誤。

今天在本文中，我將給大傢分享16種類別特征處理方法

Label encoding

Label Encoding是使用字典的方式，將每個類別標簽與不斷增加的整數相關聯，即生成一個名為class_的實例數組的索引。

Scikit-learn中的LabelEncoder是用來對分類型特征值進行編碼，即對不連續的數值或文本進行編碼。其中包含以下常用方法：

• fit(y) ：fit可看做一本空字典，y可看作要塞到字典中的詞。
• fit_transform(y)：相當於先進行fit再進行transform，即把y塞到字典中去以後再進行transform得到索引值。
• inverse_transform(y)：根據索引值y獲得原始數據。
• transform(y) ：將y轉變成索引值。

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
city_list = ["paris", "paris", "tokyo", "amsterdam"]
le.fit(city_list)
print(le.classes_)  # 輸出為：['amsterdam' 'paris' 'tokyo']
city_list_le = le.transform(city_list)  # 進行Encode
print(city_list_le)  # 輸出為：[1 1 2 0]
city_list_new = le.inverse_transform(city_list_le)  # 進行decode
print(city_list_new) # 輸出為：['paris' 'paris' 'tokyo' 'amsterdam']

多列數據編碼方式：

import pandas as pd
from sklearn.preprocessing import LabelEncoder
df = pd.DataFrame({
    'pets': ['cat', 'dog', 'cat', 'monkey', 'dog', 'dog'],
    'owner': ['Champ', 'Ron', 'Brick', 'Champ', 'Veronica', 'Ron'],
    'location': ['San_Diego', 'New_York', 'New_York', 'San_Diego', 'San_Diego',
                 'New_York']
})
d = {}
le = LabelEncoder()
cols_to_encode = ['pets', 'owner', 'location']
for col in cols_to_encode:
    df_train[col] = le.fit_transform(df_train[col])
    d[col] = le.classes_

Pandas的factorize()可以將Series中的標稱型數據映射稱為一組數字，相同的標稱型映射為相同的數字。factorize函數的返回值是一個tuple（元組），元組中包含兩個元素。第一個元素是一個array，其中的元素是標稱型元素映射為的數字；第二個元素是Index類型，其中的元素是所有標稱型元素，沒有重復。

import numpy as np
import pandas as pd
df = pd.DataFrame(['green','bule','red','bule','green'],columns=['color'])
pd.factorize(df['color'])  #(array([0, 1, 2, 1, 0], dtype=int64),Index(['green', 'bule', 'red'], dtype='object'))
pd.factorize(df['color'])[0] #array([0, 1, 2, 1, 0], dtype=int64)
pd.factorize(df['color'])[1]  #Index(['green', 'bule', 'red'], dtype='object')

Label Encoding隻是將文本轉化為數值，並沒有解決文本特征的問題：所有的標簽都變成瞭數字，算法模型直接將根據其距離來考慮相似的數字，而不考慮標簽的具體含義。使用該方法處理後的數據適合支持類別性質的算法模型，如LightGBM。

序列編碼（Ordinal Encoding）

Ordinal Encoding即最為簡單的一種思路，對於一個具有m個category的Feature，我們將其對應地映射到 [0,m-1] 的整數。當然 Ordinal Encoding 更適用於 Ordinal Feature，即各個特征有內在的順序。例如對於”學歷”這樣的類別，”學士”、”碩士”、”博士” 可以很自然地編碼成 [0,2]，因為它們內在就含有這樣的邏輯順序。但如果對於“顏色”這樣的類別，“藍色”、“綠色”、“紅色”分別編碼成[0,2]是不合理的，因為我們並沒有理由認為“藍色”和“綠色”的差距比“藍色”和“紅色”的差距對於特征的影響是不同的。

ord_map = {'Gen 1': 1, 'Gen 2': 2, 'Gen 3': 3, 'Gen 4': 4, 'Gen 5': 5, 'Gen 6': 6}
df['GenerationLabel'] = df['Generation'].map(gord_map)

獨熱編碼(One-Hot Encoding)

在實際的機器學習的應用任務中，特征有時候並不總是連續值，有可能是一些分類值，如性別可分為male和female。在機器學習任務中，對於這樣的特征，通常我們需要對其進行特征數字化，比如有如下三個特征屬性：

• 性別：[“male”，”female”]
• 地區：[“Europe”，”US”，”Asia”]
• 瀏覽器：[“Firefox”，”Chrome”，”Safari”，”Internet Explorer”]

對於某一個樣本，如[“male”，”US”，”Internet Explorer”]，我們需要將這個分類值的特征數字化，最直接的方法，我們可以采用序列化的方式：[0,1,3]。但是，即使轉化為數字表示後，上述數據也不能直接用在我們的分類器中。因為，分類器往往默認數據是連續的，並且是有序的。按照上述的表示，數字並不是有序的，而是隨機分配的。這樣的特征處理並不能直接放入機器學習算法中。

為瞭解決上述問題，其中一種可能的解決方法是采用獨熱編碼（One-Hot Encoding）。獨熱編碼，又稱為一位有效編碼。其方法是使用N位狀態寄存器來對N個狀態進行編碼，每個狀態都由他獨立的寄存器位，並且在任意時候，其中隻有一位有效。可以這樣理解，對於每一個特征，如果它有m個可能值，那麼經過獨熱編碼後，就變成瞭m個二元特征。並且，這些特征互斥，每次隻有一個激活。因此，數據會變成稀疏的。

對於上述的問題，性別的屬性是二維的，同理，地區是三維的，瀏覽器則是四維的，這樣，我們可以采用One-Hot編碼的方式對上述的樣本[“male”，”US”，”Internet Explorer”]編碼，male則對應著[1，0]，同理US對應著[0，1，0]，Internet Explorer對應著[0,0,0,1]。則完整的特征數字化的結果為：[1,0,0,1,0,0,0,0,1]。

為什麼能使用One-Hot Encoding？

使用one-hot編碼，將離散特征的取值擴展到瞭歐式空間，離散特征的某個取值就對應歐式空間的某個點。在回歸，分類，聚類等機器學習算法中，特征之間距離的計算或相似度的計算是非常重要的，而我們常用的距離或相似度的計算都是在歐式空間的相似度計算，計算餘弦相似性，也是基於的歐式空間。

將離散型特征使用one-hot編碼，可以會讓特征之間的距離計算更加合理。比如，有一個離散型特征，代表工作類型，該離散型特征，共有三個取值，不使用one-hot編碼，計算出來的特征的距離是不合理。那如果使用one-hot編碼，顯得更合理。

獨熱編碼優缺點

優點：獨熱編碼解決瞭分類器不好處理屬性數據的問題，在一定程度上也起到瞭擴充特征的作用。它的值隻有0和1，不同的類型存儲在垂直的空間。

缺點：當類別的數量很多時，特征空間會變得非常大。在這種情況下，一般可以用PCA（主成分分析）來減少維度。而且One-Hot Encoding+PCA這種組合在實際中也非常有用。

One-Hot Encoding的使用場景

獨熱編碼用來解決類別型數據的離散值問題。將離散型特征進行one-hot編碼的作用，是為瞭讓距離計算更合理，但如果特征是離散的，並且不用one-hot編碼就可以很合理的計算出距離，那麼就沒必要進行one-hot編碼，比如，該離散特征共有1000個取值，我們分成兩組，分別是400和600,兩個小組之間的距離有合適的定義，組內的距離也有合適的定義，那就沒必要用one-hot 編碼。

基於樹的方法是不需要進行特征的歸一化，例如隨機森林，bagging 和 boosting等。對於決策樹來說，one-hot的本質是增加樹的深度，決策樹是沒有特征大小的概念的，隻有特征處於他分佈的哪一部分的概念。

基於Scikit-learn 的one hot encoding

LabelBinarizer：將對應的數據轉換為二進制型，類似於onehot編碼，這裡有幾點不同：

• 可以處理數值型和類別型數據
• 輸入必須為1D數組
• 可以自己設置正類和父類的表示方式

from sklearn.preprocessing import LabelBinarizer
 
lb = LabelBinarizer()
 
city_list = ["paris", "paris", "tokyo", "amsterdam"]
 
lb.fit(city_list)
print(lb.classes_)  # 輸出為：['amsterdam' 'paris' 'tokyo']
 
city_list_le = lb.transform(city_list)  # 進行Encode
print(city_list_le)  # 輸出為：
# [[0 1 0]
#  [0 1 0]
#  [0 0 1]
#  [1 0 0]]
 
city_list_new = lb.inverse_transform(city_list_le)  # 進行decode
print(city_list_new)  # 輸出為：['paris' 'paris' 'tokyo' 'amsterdam']

OneHotEncoder隻能對數值型數據進行處理，需要先將文本轉化為數值（Label encoding）後才能使用，隻接受2D數組：

import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
def LabelOneHotEncoder(data, categorical_features):
    d_num = np.array([])
    for f in data.columns:
        if f in categorical_features:
            le, ohe = LabelEncoder(), OneHotEncoder()
            data[f] = le.fit_transform(data[f])
            if len(d_num) == 0:
                d_num = np.array(ohe.fit_transform(data[[f]]))
            else:
                d_num = np.hstack((d_num, ohe.fit_transform(data[[f]]).A))
        else:
            if len(d_num) == 0:
                d_num = np.array(data[[f]])
            else:
                d_num = np.hstack((d_num, data[[f]]))
    return d_num
df = pd.DataFrame([
    ['green', 'Chevrolet', 2017],
    ['blue', 'BMW', 2015],
    ['yellow', 'Lexus', 2018],
])
df.columns = ['color', 'make', 'year']
df_new = LabelOneHotEncoder(df, ['color', 'make', 'year'])

基於Pandas的one hot encoding

其實如果我們跳出 scikit-learn， 在 pandas 中可以很好地解決這個問題，用 pandas 自帶的get_dummies函數即可

import pandas as pd
 
df = pd.DataFrame([
    ['green', 'Chevrolet', 2017],
    ['blue', 'BMW', 2015],
    ['yellow', 'Lexus', 2018],
])
df.columns = ['color', 'make', 'year']
df_processed = pd.get_dummies(df, prefix_sep="_", columns=df.columns[:-1])
print(df_processed)

get_dummies的優勢在於:

• 本身就是 pandas 的模塊，所以對 DataFrame 類型兼容很好
• 不管你列是數值型還是字符串型，都可以進行二值化編碼
• 能夠根據指令，自動生成二值化編碼後的變量名

get_dummies雖然有這麼多優點，但畢竟不是 sklearn 裡的transformer類型，所以得到的結果得手動輸入到 sklearn 裡的相應模塊，也無法像 sklearn 的transformer一樣可以輸入到pipeline中進行流程化地機器學習過程。

頻數編碼（Frequency Encoding/Count Encoding）

將類別特征替換為訓練集中的計數（一般是根據訓練集來進行計數，屬於統計編碼的一種，統計編碼，就是用類別的統計特征來代替原始類別，比如類別A在訓練集中出現瞭100次則編碼為100）。這個方法對離群值很敏感，所以結果可以歸一化或者轉換一下（例如使用對數變換）。未知類別可以替換為1。

頻數編碼使用頻次替換類別。有些變量的頻次可能是一樣的，這將導致碰撞。盡管可能性不是非常大，沒法說這是否會導致模型退化，不過原則上我們不希望出現這種情況。

import pandas as pd
data_count = data.groupby('城市')['城市'].agg({'頻數':'size'}).reset_index()
data = pd.merge(data, data_count, on = '城市', how = 'left')

目標編碼（Target Encoding/Mean Encoding）

目標編碼（target encoding），亦稱均值編碼（mean encoding）、似然編碼（likelihood encoding）、效應編碼（impact encoding），是一種能夠對高基數（high cardinality）自變量進行編碼的方法 (Micci-Barreca 2001) 。

如果某一個特征是定性的（categorical），而這個特征的可能值非常多（高基數），那麼目標編碼（Target encoding）是一種高效的編碼方式。在實際應用中，這類特征工程能極大提升模型的性能。

一般情況下，針對定性特征，我們隻需要使用sklearn的OneHotEncoder或LabelEncoder進行編碼。

LabelEncoder能夠接收不規則的特征列，並將其轉化為從0到n-1的整數值（假設一共有n種不同的類別）；OneHotEncoder則能通過啞編碼，制作出一個m*n的稀疏矩陣（假設數據一共有m行，具體的輸出矩陣格式是否稀疏可以由sparse參數控制）。

定性特征的基數（cardinality）指的是這個定性特征所有可能的不同值的數量。在高基數（high cardinality）的定性特征面前，這些數據預處理的方法往往得不到令人滿意的結果。

高基數定性特征的例子：IP地址、電子郵件域名、城市名、傢庭住址、街道、產品號碼。

主要原因：

• LabelEncoder編碼高基數定性特征，雖然隻需要一列，但是每個自然數都具有不同的重要意義，對於y而言線性不可分。使用簡單模型，容易欠擬合（underfit），無法完全捕獲不同類別之間的區別；使用復雜模型，容易在其他地方過擬合（overfit）。
• OneHotEncoder編碼高基數定性特征，必然產生上萬列的稀疏矩陣，易消耗大量內存和訓練時間，除非算法本身有相關優化（例：SVM）。

如果某個類別型特征基數比較低（low-cardinality features），即該特征的所有值去重後構成的集合元素個數比較少，一般利用One-hot編碼方法將特征轉為數值型。One-hot編碼可以在數據預處理時完成，也可以在模型訓練的時候完成，從訓練時間的角度，後一種方法的實現更為高效，CatBoost對於基數較低的類別型特征也是采用後一種實現。

顯然，在高基數類別型特征（high cardinality features） 當中，比如 user ID，這種編碼方式會產生大量新的特征，造成維度災難。一種折中的辦法是可以將類別分組成有限個的群體再進行One-hot編碼。一種常被使用的方法是根據目標變量統計（Target Statistics，以下簡稱TS）進行分組，目標變量統計用於估算每個類別的目標變量期望值。甚至有人直接用TS作為一個新的數值型變量來代替原來的類別型變量。重要的是，可以通過對TS數值型特征的閾值設置，基於對數損失、基尼系數或者均方差，得到一個對於訓練集而言將類別一分為二的所有可能劃分當中最優的那個。在LightGBM當中，類別型特征用每一步梯度提升時的梯度統計（Gradient Statistics，以下簡稱GS）來表示。雖然為建樹提供瞭重要的信息，但是這種方法有以下兩個缺點：

• 增加計算時間，因為需要對每一個類別型特征，在迭代的每一步，都需要對GS進行計算
• 增加存儲需求，對於一個類別型變量，需要存儲每一次分離每個節點的類別

為瞭克服這些缺點，LightGBM以損失部分信息為代價將所有的長尾類別歸為一類，作者聲稱這樣處理高基數類別型特征時比One-hot編碼還是好不少。不過如果采用TS特征，那麼對於每個類別隻需要計算和存儲一個數字。因此，采用TS作為一個新的數值型特征是最有效、信息損失最小的處理類別型特征的方法。TS也被廣泛應用在點擊預測任務當中，這個場景當中的類別型特征有用戶、地區、廣告、廣告發佈者等。接下來我們著重討論TS，暫時將One-hot編碼和GS放一邊。

以下是計算公式：

其中 n 代表的是該某個特征取值的個數，

代表某個特征取值下正Label的個數，mdl為一個最小閾值，樣本數量小於此值的特征類別將被忽略，prior是Label的均值。註意，如果是處理回歸問題的話，可以處理成相應該特征下label取值的average/max。對於k分類問題，會生成對應的k-1個特征。

此方法同樣容易引起過擬合，以下方法用於防止過擬合：

• 增加正則項a的大小
• 在訓練集該列中添加噪聲
• 使用交叉驗證

目標編碼屬於有監督的編碼方式，如果運用得當則能夠有效地提高預測模型的準確性 (Pargent, Bischl, and Thomas 2019) ；而這其中的關鍵，就是在編碼的過程中引入正則化，避免過擬合問題。

例如類別A對應的標簽1有200個，標簽2有300個，標簽3有500個，則可以編碼為：2/10,3/10,3/6。中間最重要的是如何避免過擬合（原始的target encoding直接對全部的訓練集數據和標簽進行編碼，會導致得到的編碼結果太過依賴與訓練集），常用的解決方法是使用2 levels of cross-validation求出target mean，思路如下：

• 把train data劃分為20-folds （舉例：infold: fold #2-20, out of fold: fold #1）
• 計算 10-folds的 inner out of folds值 （舉例：使用inner_infold #2-10 的target的均值，來作為inner_oof #1的預測值）
• 對10個inner out of folds 值取平均，得到 inner_oof_mean
• 將每一個 infold （fold #2-20） 再次劃分為10-folds （舉例：inner_infold: fold #2-10, Inner_oof: fold #1）
• 計算oof_mean （舉例：使用 infold #2-20的inner_oof_mean 來預測 out of fold #1的oof_mean
• 將train data 的 oof_mean 映射到test data完成編碼

比如劃分為10折，每次對9折進行標簽編碼然後用得到的標簽編碼模型預測第10折的特征得到結果，其實就是常說的均值編碼。

目標編碼嘗試對分類特征中每個級別的目標總體平均值進行測量。這意味著，當每個級別的數據更少時，估計的均值將與“真實”均值相距更遠，方差更大。

from category_encoders import TargetEncoder
import pandas as pd
from sklearn.datasets import load_boston
# prepare some data
bunch = load_boston()
y_train = bunch.target[0:250]
y_test = bunch.target[250:506]
X_train = pd.DataFrame(bunch.data[0:250], columns=bunch.feature_names)
X_test = pd.DataFrame(bunch.data[250:506], columns=bunch.feature_names)
# use target encoding to encode two categorical features
enc = TargetEncoder(cols=['CHAS', 'RAD'])
# transform the datasets
training_numeric_dataset = enc.fit_transform(X_train, y_train)
testing_numeric_dataset = enc.transform(X_test)

Beta Target Encoding

Kaggle競賽Avito Demand Prediction Challenge 第14名的solution分享：14th Place Solution: The Almost Golden Defenders。和target encoding 一樣，beta target encoding 也采用 target mean value （among each category） 來給categorical feature做編碼。不同之處在於，為瞭進一步減少target variable leak，beta target encoding發生在在5-fold CV內部，而不是在5-fold CV之前：

• 把train data劃分為5-folds （5-fold cross validation）
• target encoding based on infold data
• train model
• get out of fold prediction

同時beta target encoding 加入瞭smoothing term，用 bayesian mean 來代替mean。Bayesian mean (Bayesian average) 的思路：某一個category如果數據量較少(<N_min)，noise就會比較大，需要補足數據，達到smoothing 的效果。補足數據值 = prior mean。N_min 是一個regularization term，N_min 越大，regularization效果越強。

另外，對於target encoding和beta target encoding，不一定要用target mean (or bayesian mean)，也可以用其他的統計值包括 medium, frqequency, mode, variance, skewness, and kurtosis — 或任何與target有correlation的統計值。

# train -> training dataframe
# test -> test dataframe
# N_min -> smoothing term, minimum sample size, if sample size is less than N_min, add up to N_min 
# target_col -> target column
# cat_cols -> categorical colums
# Step 1: fill NA in train and test dataframe
# Step 2: 5-fold CV (beta target encoding within each fold)
kf = KFold(n_splits=5, shuffle=True, random_state=0)
for i, (dev_index, val_index) in enumerate(kf.split(train.index.values)):
    # split data into dev set and validation set
    dev = train.loc[dev_index].reset_index(drop=True) 
    val = train.loc[val_index].reset_index(drop=True)
        
    feature_cols = []    
    for var_name in cat_cols:
        feature_name = f'{var_name}_mean'
        feature_cols.append(feature_name)
        
        prior_mean = np.mean(dev[target_col])
        stats = dev[[target_col, var_name]].groupby(var_name).agg(['sum', 'count'])[target_col].reset_index()           
   
        ### beta target encoding by Bayesian average for dev set 
        df_stats = pd.merge(dev[[var_name]], stats, how='left')
        df_stats['sum'].fillna(value = prior_mean, inplace = True)
        df_stats['count'].fillna(value = 1.0, inplace = True)
        N_prior = np.maximum(N_min - df_stats['count'].values, 0)   # prior parameters
        dev[feature_name] = (prior_mean * N_prior + df_stats['sum']) / (N_prior + df_stats['count']) # Bayesian mean
        ### beta target encoding by Bayesian average for val set
        df_stats = pd.merge(val[[var_name]], stats, how='left')
        df_stats['sum'].fillna(value = prior_mean, inplace = True)
        df_stats['count'].fillna(value = 1.0, inplace = True)
        N_prior = np.maximum(N_min - df_stats['count'].values, 0)   # prior parameters
        val[feature_name] = (prior_mean * N_prior + df_stats['sum']) / (N_prior + df_stats['count']) # Bayesian mean
        
        ### beta target encoding by Bayesian average for test set
        df_stats = pd.merge(test[[var_name]], stats, how='left')
        df_stats['sum'].fillna(value = prior_mean, inplace = True)
        df_stats['count'].fillna(value = 1.0, inplace = True)
        N_prior = np.maximum(N_min - df_stats['count'].values, 0)   # prior parameters
        test[feature_name] = (prior_mean * N_prior + df_stats['sum']) / (N_prior + df_stats['count']) # Bayesian mean
        
        # Bayesian mean is equivalent to adding N_prior data points of value prior_mean to the data set.
        del df_stats, stats
    # Step 3: train model (K-fold CV), get oof predictio

M-Estimate Encoding

M-Estimate Encoding 相當於 一個簡化版的Target Encoding：

其中𝑦+代表所有正Label的個數，m是一個調參的參數，m越大過擬合的程度就會越小，同樣的在處理連續值時𝑛+可以換成label的求和，𝑦+換成所有label的求和。

James-Stein Encoding

James-Stein Encoding 同樣是基於target的一種算法。算法的思想很簡單，對於特征的每個取值 k 可以根據下面的公式獲得：

其中B由以下公式估計：

但是它有一個要求是target必須符合正態分佈，這對於分類問題是不可能的，因此可以把y先轉化成概率的形式。或者在實際操作中，使用grid search的方法選擇一個比較好的B值。

Weight of Evidence Encoder

Weight Of Evidence 同樣是基於target的方法。

使用WOE作為變量，第i類的WOE等於：

WOE特別合適邏輯回歸，因為Logit=log(odds)。WOE編碼的變量被編碼為統一的維度（是一個被標準化過的值），變量之間直接比較系數即可。

Leave-one-out Encoder (LOO or LOOE)

這個方法類似於SUM的方法，隻是在計算訓練集每個樣本的特征值轉換時都要把該樣本排除(消除特征某取值下樣本太少導致的嚴重過擬合)，在計算測試集每個樣本特征值轉換時與SUM相同。可見以下公式：

Binary Encoding

把每一類的序號用二進制進行編碼，使用log2N維向量來編碼N類。例如：(0,0)代表第一類，(0,1)代表第二類，(1,0)代表第三類，(1,1)代表第四類

Hashing Encoding

類似於One-hot encoding，但是通過hash函數映射到一個低維空間，並且使得兩個類對應向量的空間距離基本保持一致。使用低維空間來降低瞭表示向量的維度。

特征哈希可能會導致要素之間發生沖突。但哈希編碼的優點是它不需要制定和維護原變量與新變量之間的映射關系。因此，哈希編碼器的大小及復雜程度不隨數據類別的增多而增多。

Probability Ratio Encoding

和WOE相似，隻是去掉瞭log，即：

Sum Encoder (Deviation Encoder, Effect Encoder)

求和編碼通過比較某一特征取值下對應標簽（或其他相關變量）的均值與標簽的均值之間的差別來對特征進行編碼。如果做不好細節，這個方法非常容易出現過擬合，所以需要配合留一法或者五折交叉驗證進行特征的編碼。還有根據方差加入懲罰項防止過擬合的方法。

Helmert Encoding

Helmert編碼通常在計量經濟學中使用。在Helmert編碼（分類特征中的每個值對應於Helmert矩陣中的一行）之後，線性模型中編碼後的變量系數可以反映在給定該類別變量某一類別值的情形下因變量的平均值與給定該類別其他類別值的情形下因變量的平均值的差值。

Helmet編碼是僅次於One-Hot Encoding和Sum Encoder使用最廣泛的編碼方法，與Sum Encoder不同的是，它比較的是某一特征取值下對應標簽（或其他相關變量）的均值與他之前特征的均值之間的差異，而不是和所有特征的均值比較。這個特征同樣容易出現過擬合的情況。

CatBoost Encoding

對於可取值的數量比獨熱最大量還要大的分類變量，CatBoost 使用瞭一個非常有效的編碼方法，這種方法和均值編碼類似，但可以降低過擬合情況。它的具體實現方法如下：

• 將輸入樣本集隨機排序，並生成多組隨機排列的情況。
• 將浮點型或屬性值標記轉化為整數。
• 將所有的分類特征值結果都根據以下公式，轉化為數值結果。

其中 CountInClass 表示在當前分類特征值中，有多少樣本的標記值是1；Prior 是分子的初始值，根據初始參數確定。TotalCount 是在所有樣本中（包含當前樣本），和當前樣本具有相同的分類特征值的樣本數量。

CatBoost處理Categorical features總結：

首先，他們會計算一些數據的statistics。計算某個category出現的頻率，加上超參數，生成新的numerical features。這一策略要求同一標簽數據不能排列在一起（即先全是0之後全是1這種方式），訓練之前需要打亂數據集。

第二，使用數據的不同排列（實際上是4個）。在每一輪建立樹之前，先扔一輪骰子，決定使用哪個排列來生成樹。

第三，考慮使用categorical features的不同組合。例如顏色和種類組合起來，可以構成類似於blue dog這樣的feature。當需要組合的categorical features變多時，catboost隻考慮一部分combinations。在選擇第一個節點時，隻考慮選擇一個feature，例如A。在生成第二個節點時，考慮A和任意一個categorical feature的組合，選擇其中最好的。就這樣使用貪心算法生成combinations。

第四，除非向gender這種維數很小的情況，不建議自己生成one-hot vectors，最好交給算法來處理。

到此這篇關於16中Python機器學習類別特征處理方法總結的文章就介紹到這瞭,更多相關Python類別特征處理內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：

• python的numpy模塊實現邏輯回歸模型
• Python Pandas 中的數據結構詳解
• python機器學習樸素貝葉斯算法及模型的選擇和調優詳解
• 使用pandas模塊實現數據的標準化操作
• python機器學習算法與數據降維分析詳解