类别特征编码 ———特征工程

井底哇哇

于 2024-08-23 17:53:20 发布

阅读量913

点赞数 18

文章标签：算法哈希算法

本文链接：https://blog.csdn.net/weixin_41187013/article/details/141470493

版权

1. 标签编码（Label Encoding）

实现逻辑：将类别数据映射到从0到n-1的整数上，其中n是类别的总数。

适用场景：适用于有序类别或当模型能够处理整数编码的情况。

可能存在问题：如果类别数据是无序的，则标签编码会引入错误的顺序关系，导致模型表现不佳。

Python实现：

from sklearn.preprocessing import LabelEncoder  
le = LabelEncoder()  
X_encoded = le.fit_transform(X['categorical_column'])

2. 独热编码（One-Hot Encoding）

实现逻辑：为每个类别创建一个二进制列，如果数据项属于该类别，则在该列上置1，否则置0。

适用场景：适用于无序的类别数据，可以处理缺失值。

可能存在问题：当类别数量很多时，会导致高维稀疏矩阵，增加计算复杂度。

Python实现：

X_encoded = pd.get_dummies(X['categorical_column'])

3. 目标编码（Target Encoding）

实现逻辑：根据每个类别的目标变量平均值或中位数来编码类别。

适用场景：当类别变量与目标变量之间存在强相关性时。

可能存在问题：过拟合风险高，尤其是当某个类别的样本很少时。

Python实现（使用category_encoders库）：

import category_encoders as ce  
target_enc = ce.TargetEncoder(cols=['categorical_column'])  
X_encoded = target_enc.fit_transform(X, y)

4. 哈希编码（Hashing Encoding）

实现逻辑：通过哈希函数将类别数据映射到一个固定大小的整数数组上。

适用场景：类别数量非常多，且不需要了解具体类别含义的情况。

可能存在问题：哈希冲突可能导致信息丢失，且编码结果不稳定。

Python实现（使用FeatureHasher）：

from sklearn.feature_extraction.text import FeatureHasher  
hasher = FeatureHasher(n_features=10, input_type='string')  
X_encoded = hasher.fit_transform(X['categorical_column'].astype(str))

5.二进制编码（Binary Encoding）

实现逻辑

二进制编码是一种将类别标签转换为二进制数的编码方法。它通常适用于类别数量适中（即类别数量可以表示为2的幂次减一）且类别之间具有明确顺序的情况。编码时，从最低有效位（LSB）到最高有效位（MSB），每个二进制位代表类别的一个层级或分组。

例如，如果有4个有序类别（A, B, C, D），可以编码为：

A: 00
B: 01
C: 10
D: 11

注意，如果类别数量不是2的幂次减一，那么一些二进制数可能不会被使用，或者需要添加额外的填充位。

适用场景

类别数量适中，且类别之间存在明确的顺序关系。
需要通过编码保持类别之间的顺序信息。
在需要减少类别数量的特征维度但又不想完全失去顺序信息时。

可能存在的问题

如果类别数量不是2的幂次减一，可能会浪费一些二进制位或需要额外的填充位，这可能导致编码不够紧凑。
如果类别之间的顺序关系不明显或不存在，使用二进制编码可能不合适。
二进制编码可能会使模型对类别之间的微小变化过于敏感，因为相邻的二进制编码在数值上差异很大。

Python实现

Python中没有直接实现二进制编码的函数，但可以通过自定义函数来实现:

def binary_encode(labels, num_classes):  
    """  
    对有序类别标签进行二进制编码。  
      
    参数:  
    - labels: 类别标签的列表或数组，假设它们是有序的且从0开始。  
    - num_classes: 类别总数，应该是2的幂次减一。  
      
    返回:  
    - encoded_labels: 编码后的二进制数，以字符串形式表示。  
    """  
    # 检查num_classes是否是2的幂次减一  
    if (num_classes & (num_classes - 1)) != 0:  
        raise ValueError("num_classes should be a power of 2 minus 1")  
      
    # 计算需要的二进制位数  
    bits = int(np.log2(num_classes + 1))  
      
    # 初始化编码后的标签列表  
    encoded_labels = []  
      
    # 对每个标签进行编码  
    for label in labels:  
        # 将标签转换为二进制字符串，并填充前导0以达到所需的位数  
        binary_str = format(label, f'0{bits}b')  
        encoded_labels.append(binary_str)  
      
    return encoded_labels  
  
# 示例  
labels = [0, 1, 2, 3]  # 假设有4个有序类别  
num_classes = 3  # 注意：这里应该使用3（因为类别是从0开始的），但按定义应为2^n-1，所以这里只是示例  
# 注意：在实际应用中，应该根据实际的类别总数来设置num_classes  
try:  
    encoded_labels = binary_encode(labels, num_classes)  
    print(encoded_labels)  # 这将引发ValueError，因为num_classes不是2的幂次减一  
except ValueError as e:  
    print(e)  
  
# 正确的使用方式（假设有7个类别）  
labels = [0, 1, 2, 3, 4, 5, 6]  
num_classes = 7  # 实际上应该是2^3-1=7，因为类别是从0开始的  
encoded_labels = binary_encode(labels, num_classes-1)  # 减1是因为函数内部会+1  
print(encoded_labels)  # 输出编码后的二进制字符串列表

6.对比求和编码（Sum Encoding）

实现逻辑

对比求和编码（有时也称为对比编码或影响编码）是一种特征编码方法，它基于目标变量（或称为响应变量）的值来计算每个类别的编码。具体来说，对于某个类别，其编码是通过计算该类别中所有样本的目标变量值与非该类别中所有样本的目标变量值之差（或某种聚合后的差异）来得到的。这种编码方式旨在捕捉每个类别相对于其他类别的“影响”或“贡献”。

然而，需要注意的是，上述描述是一个比较宽泛的概念，具体的实现方式可能会有所不同。一种常见的实现是计算每个类别的目标变量平均值与整体平均值的差异，并以此为编码值。

适用场景

当类别变量与目标变量之间存在显著的差异或影响时。
需要量化每个类别对目标变量的相对贡献时。
数据集中存在显著的类别不平衡时，这种方法可以帮助模型更好地理解每个类别的独特性质。

可能存在的问题

可能会受到极端值的影响，尤其是当目标变量中存在极端值时。
依赖于目标变量的具体分布，如果目标变量的分布非常均匀，则编码的差异可能不明显。
如果数据集中的类别数量非常多，或者某些类别的样本数量非常少，那么计算得到的编码值可能会受到噪声的影响。

Python实现

下面是一个简单的Python实现示例，该示例计算了每个类别的目标变量平均值与整体平均值的差异作为编码值：

import pandas as pd  
import numpy as np  
  
def sum_encoding(X, y, cat_col):  
    """  
    对类别特征进行对比求和编码。  
      
    参数:  
    - X: DataFrame，包含类别特征和其他特征。  
    - y: Series，目标变量。  
    - cat_col: 字符串，需要编码的类别特征的列名。  
      
    返回:  
    - encoded_series: Series，编码后的值。  
    """  
    # 计算整体平均值  
    overall_mean = y.mean()  
      
    # 对每个类别计算目标变量平均值  
    group_means = X.groupby(cat_col)[y].mean()  
      
    # 计算编码值：类别平均值 - 整体平均值  
    encoded_series = group_means[X[cat_col]].values - overall_mean  
      
    return encoded_series  
  
# 示例数据  
data = {  
    'category': ['A', 'B', 'A', 'C', 'B', 'A'],  
    'target': [1, 2, 3, 4, 5, 6]  
}  
  
df = pd.DataFrame(data)  
  
# 调用函数进行编码  
encoded_values = sum_encoding(df, df['target'], 'category')  
  
# 将编码值添加到原始DataFrame中  
df['encoded_category'] = encoded_values  
  
print(df)

7.后向差分编码（Backward Difference Encoding）

实现逻辑

后向差分编码是一种数据转换技术，它通过对原始数据序列中的连续值进行后向差分（即当前值与前一个值的差）来生成新的数据序列。这种编码方法通常用于时间序列数据，以减少数据中的趋势成分，使数据更加平稳，便于后续的分析或建模。

具体来说，对于原始数据序列 x1,x2,…,xn，其后向差分编码序列 y1,y2,…,yn−1 可以通过以下方式计算：

yi=xi+1−xifori=1,2,…,n−1

注意，由于差分操作会减少一个数据点（因为第一个数据点没有前一个值可以与之相减），所以差分后的序列长度会比原始序列短一个单位。

适用场景

时间序列分析，特别是当数据中存在明显的趋势或季节性模式时。
需要减少数据中的噪声或趋势成分，以便更好地观察数据的周期性或随机性特征。
在某些机器学习算法中，如ARIMA模型，差分是预处理步骤之一，用于使数据更加平稳。

可能存在的问题

差分操作会丢失原始数据序列中的一个数据点，这可能会影响后续分析的准确性。
如果原始数据序列中的噪声较大，差分可能会放大这些噪声。
差分后的数据可能不再具有原始数据的某些重要特征，如非负性。

Python实现

下面是一个简单的Python实现示例，展示了如何对一维数组（或Pandas Series）进行后向差分编码：

import numpy as np  
import pandas as pd  
  
def backward_difference_encoding(data):  
    """  
    对一维数组或Pandas Series进行后向差分编码。  
      
    参数:  
    - data: 一维数组或Pandas Series。  
      
    返回:  
    - 差分后的数组或Pandas Series。  
    """  
    # 确保输入是Pandas Series，以便使用diff方法  
    if not isinstance(data, pd.Series):  
        data = pd.Series(data)  
      
    # 计算后向差分  
    diff_data = data.diff(-1)  # 注意：diff的默认参数是1，表示前向差分；这里使用-1表示后向差分  
      
    # 由于diff方法会生成NaN作为第一个元素（因为没有前一个值可以相减），我们将其删除  
    diff_data = diff_data.dropna()  
      
    # 如果需要，可以将结果转换回NumPy数组  
    # diff_data_np = diff_data.values  
      
    return diff_data  
  
# 示例数据  
data = np.array([1, 3, 6, 10, 15])  
  
# 调用函数进行后向差分编码  
diff_data = backward_difference_encoding(data)  
  
# 打印结果  
print(diff_data)

8.海尔默特编码 (helmert encoding)

实现逻辑（假设为Helmert变换的简化）

Helmert变换通常用于多变量分析中，以去除变量之间的线性关系，实现数据的正交化。在简化的“海尔默特编码”上下文中，我们可以想象一个过程，它通过对数据集中的变量进行线性组合来生成新的变量，这些新变量是原始变量的正交（即不相关）版本。

然而，对于单个变量的“编码”，我们可能需要一个不同的解释。一个可能的解释是，海尔默特编码可能指的是对数据进行某种形式的标准化或去趋势处理，类似于差分但更复杂。但在这里，我将侧重于一个更通用的“编码”概念，即数据转换。

适用场景

当数据集包含多个相关变量，并且需要去除这些变量之间的线性关系时。
在需要对数据进行预处理以符合特定模型假设（如线性回归模型中的独立性假设）时。
在时间序列分析中，去除趋势或季节性成分。

可能存在的问题

如果错误地应用了Helmert变换（或类似的“编码”），可能会导致数据丢失重要信息。
变换后的数据可能不再具有原始数据的直观解释。
需要仔细选择变换的参数（尽管在标准的Helmert变换中，这些参数通常是固定的）。

Python实现（假设为去趋势处理的简化示例）

由于“海尔默特编码”不是一个标准的术语，以下是一个简化的Python实现，它使用线性回归来去除时间序列数据中的趋势（这可以被视为一种非常粗略的“编码”过程）：

import numpy as np  
import pandas as pd  
from sklearn.linear_model import LinearRegression  
  
def helmert_like_encoding_detrend(data):  
    """  
    使用线性回归去除时间序列数据中的趋势（简化的“海尔默特编码”示例）。  
      
    参数:  
    - data: Pandas Series，时间序列数据。  
      
    返回:  
    - detrended_data: Pandas Series，去趋势后的数据。  
    """  
    # 创建时间索引（假设data的索引已经是时间序列）  
    time_index = np.arange(len(data))  
      
    # 使用线性回归拟合趋势  
    model = LinearRegression().fit(time_index.reshape(-1, 1), data)  
      
    # 预测趋势  
    trend = model.predict(time_index.reshape(-1, 1))  
      
    # 去趋势  
    detrended_data = data - trend  
      
    return pd.Series(detrended_data, index=data.index)  
  
# 示例数据  
time_series = pd.Series(np.random.randn(100).cumsum() + np.linspace(0, 100, 100), index=pd.date_range(start='20230101', periods=100))  
  
# 调用函数进行去趋势处理  
detrended_ts = helmert_like_encoding_detrend(time_series)  
  
# 打印结果  
print(detrended_ts.head())

9.多项式编码(polynomialencoder)

实现逻辑（假设为多项式特征生成）

如果我们假设“多项式编码”是指通过多项式特征生成来扩展分类变量的编码，那么实现逻辑将涉及以下步骤：

对分类变量进行独热编码。
生成独热编码变量之间的多项式交互项（例如，二次项、三次项等）。

适用场景

当分类变量之间存在潜在的交互效应，并且这些效应对模型预测很重要时。
在需要提高模型复杂度和拟合能力的情况下，但需注意过拟合的风险。

可能存在的问题

随着多项式阶数的增加，特征数量会迅速增长，可能导致维数灾难和过拟合。
需要仔细选择多项式的阶数，以避免引入不必要的复杂性和噪声。
多项式特征可能不总是能够有效地捕获类别之间的实际关系。

Python实现（使用scikit-learn的PolynomialFeatures）

以下是一个简化的示例，展示了如何对分类变量进行独热编码，并尝试（尽管不太标准）使用多项式特征生成来扩展这些编码：

import pandas as pd  
import numpy as np  
from sklearn.preprocessing import OneHotEncoder  
  
# 示例数据  
data = pd.DataFrame({  
    'category': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'A', 'B', 'C']  
})  
  
# 对分类变量进行独热编码  
encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')  
encoded_data = encoder.fit_transform(data[['category']])  
  
# 将编码后的数组转换回DataFrame，以便于处理  
columns = encoder.get_feature_names_out(['category'])  
encoded_df = pd.DataFrame(encoded_data, columns=columns)  
  
# 模拟多项式特征生成（这里只是简单地生成了所有可能的二元组合）  
# 注意：这不是真正的多项式特征，只是独热编码的二元组合  
def generate_pseudo_polynomial_features(df):  
    # 获取所有列的组合（除了自我组合）  
    from itertools import combinations  
    features = []  
    for r in range(2, len(df.columns) + 1):  # 生成r个元素的组合  
        for combo in combinations(df.columns, r):  
            new_col_name = '_'.join(combo)  
            features.append(df[list(combo)].prod(axis=1, min_count=1))  # 使用乘积来模拟“交互”  
            features.append(df[list(combo)].mean(axis=1))  # 也可以添加其他类型的组合，如均值  
      
    # 将新特征添加到DataFrame中  
    result_df = pd.DataFrame(features).T  
    result_df.columns = [f'poly_{i}' for i in range(len(result_df.columns))]  
    return result_df  
  
# 应用函数  
pseudo_poly_features = generate_pseudo_polynomial_features(encoded_df)  
  
# 查看结果  
print(pseudo_poly_features.head())

10. 梯度提升编码（CatBoost Encoder）

实现逻辑

梯度提升编码，特别是在CatBoost框架中，是一种用于处理分类特征的技术。CatBoost通过构建多个决策树来预测目标变量，并在构建过程中学习如何将分类特征转换为数值特征。具体来说，CatBoost会为每个类别计算一个数值分数，这个分数是基于该类别在已构建树中的平均目标响应（对于回归问题）或平均类别概率（对于分类问题）来计算的。

适用场景

当数据集中包含大量分类特征时。
当分类特征中的类别数量较多，且类别之间可能存在复杂关系时。
当需要自动处理缺失值时（CatBoost可以处理分类特征的缺失值）。

可能存在的问题

过拟合风险：如果类别数量非常多或数据集很小，可能会发生过拟合。
计算成本：构建多个决策树来计算编码可能会增加计算时间和资源消耗。

Python实现

CatBoost Encoder 通常不需要显式地“编码”，因为 CatBoost 库在训练模型时会自动处理分类特征。但是，如果你想要模拟这个过程或提取这些编码用于其他模型，你可能需要自定义实现或使用CatBoost的预测功能来间接获取。

from catboost import CatBoostClassifier, Pool  
  
# 假设X是特征数据（包含分类和数值特征），y是目标变量  
# 注意：CatBoost可以直接处理分类特征，无需显式编码  
  
# 训练CatBoost模型  
model = CatBoostClassifier(iterations=100, depth=6, learning_rate=1, loss_function='Logloss')  
model.fit(X, y, cat_features=categorical_indices)  # categorical_indices是分类特征的索引列表  
  
# 如果你想获取类似于编码的值，你可以使用模型预测概率或叶子索引  
# 但这通常不是CatBoost编码的直接用途  
  
# 另一种方法是使用CatBoost的预测功能来间接获取“编码”  
# 例如，通过查看模型对每个类别的预测响应

11. 频数编码（Count Encoding）

实现逻辑

频数编码是一种简单的编码方法，它用每个类别在数据集中出现的次数（或频率）来替换该类别。这可以是一个绝对计数或相对频率（即每个类别出现的次数除以总观测数）。

适用场景

当分类特征中的某些类别比其他类别更常见时。
当类别频率与目标变量之间存在某种关系时。

可能存在的问题

过度强调频繁类别：如果某些类别非常频繁，它们的编码值可能会过高，从而影响模型的公平性。
对新数据不友好：如果新数据中包含训练集中未见的类别，则需要一种处理未知类别的方法。

Python实现

import pandas as pd  
  
# 假设df是包含分类特征的DataFrame，'category'是分类特征的列名  
  
# 计算绝对频数编码  
df['category_count'] = df['category'].map(df['category'].value_counts())  
  
# 计算相对频率编码  
total_count = df['category'].size  
df['category_freq'] = df['category'].map(df['category'].value_counts()) / total_count

12. WOE编码（Weight of Evidence Encoding）

实现逻辑

WOE编码是一种用于信用评分和其他分类问题的编码方法。它计算了每个类别中“好”观测（例如，未违约的贷款）与“坏”观测（例如，违约的贷款）的比率的对数。这有助于量化不同类别对目标变量的影响。

适用场景

信贷评分、欺诈检测等分类问题，其中目标变量是二元的，并且存在明显的“好”与“坏”类别。

可能存在的问题

需要定义“好”和“坏”的标准。
对新数据不友好：如果新数据中包含训练集中未见的类别，则需要一种处理未知类别的方法。

Python实现

import pandas as pd  
import numpy as np  
  
# 假设df是包含分类特征和二元目标变量的DataFrame  
# 'category'是分类特征的列名，'target'是二元目标变量的列名（0表示“坏”，1表示“好”）  
  
# 计算每个类别的“好”和“坏”观测数  
good_counts = df[df['target'] == 1]['category'].value_counts()  
bad_counts = df[df['target'] == 0]['category'].value_counts()  
  
# 合并两个计数系列，用0填充缺失的类别  
all_categories = pd.concat([good_counts, bad_counts], axis=1, fill_value=0).reset_index()  
all_categories.columns = ['category', 'good_count', 'bad_count']  
  
# 计算WOE  
def calculate_woe(good, bad, total_good, total_bad):  
    if good == 0:  
        # 避免除以零，当好的观测数为零时，返回较大的负值  
        return np.log(np.finfo(float).eps)  # 使用浮点数的epsilon作为底数  
    elif bad == 0:  
        # 当坏的观测数为零时，返回较大的正值  
        return np.log(total_good / np.finfo(float).eps)  
    else:  
        # 正常计算WOE  
        return np.log(good / bad) - np.log(total_good / total_bad)  
  
total_good = good_counts.sum()  
total_bad = bad_counts.sum()  
  
# 应用WOE函数  
all_categories['woe'] = all_categories.apply(lambda x: calculate_woe(x['good_count'], x['bad_count'], total_good, total_bad), axis=1)  
  
# 将WOE编码添加回原始DataFrame（或根据需要保留）  
df_with_woe = pd.merge(df, all_categories[['category', 'woe']], on='category', how='left').fillna(0)  # 填充未知类别的WOE为0  
  
# 现在df_with_woe包含了原始的DataFrame和对应的WOE编码  
# 注意：这里假设了所有在df中出现的'category'值都已经在all_categories中计算了WOE  
# 如果存在df中有但all_categories中没有的类别，它们将填充为NaN，然后我们通过fillna(0)将其替换为0

（待验证！！！）