**机器学习类别变量常用编码方式（部分编码方式可以解决独热编码过于稀疏问题**）

环境：Python 3.9+category_encoders模块（pip install category_encoders）

1、导入各编码函数

# http://contrib.scikit-learn.org/category_encoders，category_encoders官方文档

# 第一类，自编码器，与目标值无关
from category_encoders import BackwardDifferenceEncoder
from category_encoders import BinaryEncoder               # 二进制编码  按序号二进制分列
from category_encoders import CountEncoder                # 频率编码
from category_encoders import HashingEncoder              # 哈希编码 会分列
from category_encoders import HelmertEncoder
from category_encoders import OneHotEncoder               # 独热编码，分列
from category_encoders import SumEncoder
from category_encoders import OrdinalEncoder              # 序列编码，不分列
from category_encoders import PolynomialEncoder
from category_encoders import BaseNEncoder                #  BASE-N编码(n进制编码器 n=2和binaryencoder编码器结果一样)

# 第二类、目标编码器，类别编码与类别预测目标值相关
from category_encoders import TargetEncoder               # 目标编码(类别编号取类别目标值均值)
from category_encoders import LeaveOneOutEncoder          # 留一法(类别编号取类别目标值均值,但去除本行)
from category_encoders import WOEEncoder                  # 证据权重编码
from category_encoders import MEstimateEncoder
from category_encoders import JamesSteinEncoder
from category_encoders import CatBoostEncoder           
from category_encoders import GLMMEncoder
from category_encoders import QuantileEncoder             # 分位数编码(类别编号取类别目标值分位数值，有平滑)
from category_encoders import SummaryEncoder


import pandas as pd

样本数据：

test_data = pd.DataFrame({'x':['中国','美国','日本','中国','美国','日本','中国','美国','日本','日本'],'y':[5,3,1,10,6,2,8,6,4,4]})
test_data

'''
	x	y
0	中国	5
1	美国	3
2	日本	1
3	中国	10
4	美国	6
5	日本	2
6	中国	8
7	美国	6
8	日本	4
9	日本	49

'''

2、第一类，自编码器**

2.1、序列编码

# 类别多，编码数值对于模型来说有大小之分，可以使用二进制编码代替
ordinalencoder = OrdinalEncoder()

ordinalencoder.fit_transform(test_data['x'])

'''
	x
0	1
1	2
2	3
3	1
4	2
5	3
6	1
7	2
8	3
9	3
'''

2.2、频率编码

countencoder = CountEncoder()
countencoder.fit_transform(test_data['x'])
'''
	x
0	3
1	3
2	4
3	3
4	3
5	4
6	3
7	3
8	4
9	4
'''

2.3、哈希编码

# 哈希编码,会分列，优点：长度固定（不考虑类别总量）
hashingencoder = HashingEncoder(n_components=8)
hashingencoder.fit_transform(test_data['x'])
'''
	col_0	col_1	col_2	col_3	col_4	col_5	col_6	col_7
0	0	0	0	0	0	0	0	1
1	1	0	0	0	0	0	0	0
2	0	0	0	1	0	0	0	0
3	0	0	0	0	0	0	0	1
4	1	0	0	0	0	0	0	0
5	0	0	0	1	0	0	0	0
6	0	0	0	0	0	0	0	1
7	1	0	0	0	0	0	0	0
8	0	0	0	1	0	0	0	0
9	0	0	0	1	0	0	0	0
'''

2.4、独热编码

# 类别变量，常用编码器，但类别多时，过于稀疏，占用空间大，
#（且对神经网络来说，优化一片空白空间，浪费资源，类别多时，可以使用目标编码器代替）
onehotencoder = OneHotEncoder()
onehotencoder.fit_transform(test_data['x'])
'''
	x_1	x_2	x_3
0	1	0	0
1	0	1	0
2	0	0	1
3	1	0	0
4	0	1	0
5	0	0	1
6	1	0	0
7	0	1	0
8	0	0	1
9	0	0	1
'''

2.5、二进制编码

# 就是再序列编码的基础上，将序号使用二进制位表示，解决序号有大小，对模型的干扰问题
binaryencoder = BinaryEncoder()
binaryencoder.fit_transform(test_data['x'])
'''
	x_0	x_1
0	0	1
1	1	0
2	1	1
3	0	1
4	1	0
5	1	1
6	0	1
7	1	0
8	1	1
9	1	1
'''

2.6、BASE-N编码

# n进制编码器 n=2和binaryencoder编码器结果一样
baseNEncoder = BaseNEncoder(base=2)
baseNEncoder.fit_transform(test_data['x'])
'''
	x_0	x_1
0	0	1
1	1	0
2	1	1
3	0	1
4	1	0
5	1	1
6	0	1
7	1	0
8	1	1
9	1	1
'''

3、第二类，目标编码器**

3.1、目标编码

# 类别编码使用其类别对应目标值的均值代替，对y值敏感（y异常值）
targetEncoder  = TargetEncoder()
targetEncoder.fit_transform(test_data['x'],y=test_data['y'])
'''
	x
0	7.336872
1	4.988080
2	2.851966
3	7.336872
4	4.988080
5	2.851966
6	7.336872
7	4.988080
8	2.851966
9	2.851966
'''

3.2、留一法编码

# 留一法编码,(与目标编码类似，但计算目标均值去除本行,优化目标编码的异常问题)
leaveOneOutEncoder  = LeaveOneOutEncoder()
leaveOneOutEncoder.fit_transform(test_data['x'],y=test_data['y'])

'''
	x
0	9.000000
1	6.000000
2	3.333333
3	6.500000
4	4.500000
5	3.000000
6	7.500000
7	4.500000
8	2.333333
9	2.333333
'''

3.3、分位数编码（有平滑）

quantileEncoder  = QuantileEncoder()
quantileEncoder.fit_transform(test_data['x'],y=test_data['y'])

'''
     x
0	7.125
1	5.625
2	3.300
3	7.125
4	5.625
5	3.300
6	7.125
7	5.625
8	3.300
9	3.300

'''

3.4、证据权重编码

# 要求二分类
wOEEncoder  = WOEEncoder()
wOEEncoder.fit_transform(test_data['x'],y=[0,0,1,0,0,1,0,0,1,1])
'''
x
0	-1.098612
1	-1.098612
2	1.897120
3	-1.098612
4	-1.098612
5	1.897120
6	-1.098612
7	-1.098612
8	1.897120
9	1.897120
'''