深度学习中独热编码(One-Hot Encoding)

缘友一世

于 2025-05-17 12:46:16 发布

阅读量807

点赞数 17

分类专栏：深度学习文章标签：深度学习人工智能编码

本文链接：https://blog.csdn.net/yang2330648064/article/details/148025348

版权

深度学习专栏收录该内容

35 篇文章

订阅专栏

文章目录

独热编码
实际使用分析：对对象类型使用独热编码
- 为什么使用独热编码是合适的？
- - 🔍 建议改进（可选）：

独热编码

独热编码(One-Hot Encoding)是一种将分类变量转换为机器学习算法更易理解形式的编码方法。在深度学习中，它常用于处理离散型分类特征，特别是当这些特征没有内在的顺序关系时。
独热编码的基本思想是：对于一个有 $N$ 个不同类别的分类变量，创建一个长度为 $N$ 的二进制向量，其中只有一位是1（表示当前类别），其余都是0。例如，对于"颜色"这个分类变量，可能的取值有[“红”, “绿”, “蓝”]：
- “红” → [1, 0, 0]
- “绿” → [0, 1, 0]
- “蓝” → [0, 0, 1]

独热编码的作用

解决分类数据不可计算问题：原始的分类标签（如"红"、“绿”、“蓝”）无法直接参与数学运算，转换为数值形式后可以被模型处理。
消除类别间的虚假顺序关系：如果简单地将类别映射为1,2,3等数字，模型可能会错误地认为这些数字之间存在顺序或距离关系。
适应分类输出的需求：在分类任务中，神经网络的输出层通常使用softmax激活函数，需要与独热编码形式的标签配合使用。

独热编码的优点

简单直观：编码方式直接，易于理解和实现。
保留类别平等性：所有类别在编码后都具有相同的距离（欧氏距离为√2），没有隐含的优先级。
兼容大多数算法：适用于各种机器学习算法，特别是神经网络。
处理新增类别方便：在测试集中出现新类别时，可以简单地扩展编码维度。

独热编码的缺点

维度灾难：当类别数量很多时（如词汇表很大的文本数据），编码后的特征空间会变得非常稀疏和高维。
信息独立假设：假设各个类别之间完全独立，忽略了可能存在的内在关系。
内存消耗大：高维稀疏表示会占用较多内存。
不适合有序分类变量：对于有明确顺序关系的分类变量（如"小"、“中”、“大”），独热编码会丢失顺序信息。

场景选择

适用场景：适用于无序的类别型特征（如颜色、性别等）。
不适用情况：对于有序的类别（如“低”、“中”、“高”），通常更适合用标签编码（Label Encoding）或者根据具体问题设计其他编码方式。

独热编码（PyTorch实现）

PyTorch示例展示如何使用独热编码处理分类数据：

import torch
import torch.nn as nn
import torch.optim as optim

# 示例数据：3个样本，每个样本有2个分类特征
# 特征1: 颜色 ["红", "绿", "蓝"] → 3个类别
# 特征2: 大小 ["小", "中", "大"] → 3个类别
raw_data = [
    ['红', '大'],
    ['绿', '中'],
    ['蓝', '小']
]
print("\n原始数据:")
print(raw_data)

# 定义类别映射
color_map = {'红': 0, '绿': 1, '蓝': 2}
size_map = {'小': 0, '中': 1, '大': 2}

# 转换为索引
index_data = [  [color_map[x[0]], size_map[x[1]]] for x in raw_data ]

# 转换为PyTorch张量
index_tensor = torch.LongTensor(index_data)
print("\n索引表示:")
print(index_tensor)

# 使用scatter_进行独热编码
def one_hot_encode(index_tensor, num_classes):
    # 创建一个全零张量 (样本数 × 类别数)
    one_hot = torch.zeros(index_tensor.size(0), num_classes)
    # 使用scatter_将对应位置设为1
    one_hot.scatter_(1, index_tensor.unsqueeze(1), 1)
    return one_hot

# 对每个特征单独编码
color_one_hot = one_hot_encode(index_tensor[:, 0], num_classes=3)
size_one_hot = one_hot_encode(index_tensor[:, 1], num_classes=3)

# 合并特征
features = torch.cat([color_one_hot, size_one_hot], dim=1)

print("\n独热编码后的特征矩阵:")
print(features)

# 示例模型训练
# 假设我们有一个简单的分类任务
# 创建一些随机标签
labels = torch.LongTensor([0, 1, 0])

# 定义一个简单模型
class SimpleClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(SimpleClassifier, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)
        
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

# 初始化模型
input_size = 6  # 3(颜色) + 3(大小)
hidden_size = 4
num_classes = 2
model = SimpleClassifier(input_size, hidden_size, num_classes)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# 训练循环
for epoch in range(100):
    # 前向传播
    outputs = model(features.float())
    loss = criterion(outputs, labels)
    
    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}')

# 测试模型
with torch.no_grad():
    outputs = model(features.float())
    _, predicted = torch.max(outputs.data, 1)
    print("\n预测结果:", predicted)

替代方案

对于类别数量特别多的情况，可以考虑以下替代方案：

嵌入层(Embedding Layer)：特别适用于自然语言处理任务，将高维独热向量映射到低维连续空间。
二进制编码：使用二进制位来表示类别，可以减少维度。
特征哈希：使用哈希函数将类别映射到固定维度的向量。
目标编码：用目标变量的统计量（如均值）来代表类别。

实际使用分析：对对象类型使用独热编码

# 对对象类型的特征进行独热编码
all_features = pd.get_dummies(all_features, columns=object_feats, dummy_na=True)

这行代码会对所有非数值型（object 类型）的特征列进行 One-Hot 编码，并且设置 dummy_na=True 会把缺失值（NaN）也作为一个单独的类别处理。

为什么使用独热编码是合适的？

📌 场景说明：

数据集中包含一些类别型特征（如：房屋所在区域、建筑风格等），它们通常以字符串或枚举形式存在。
神经网络模型只能处理数值型数据，无法理解字符串或其他非结构化格式。

📌 为什么要用独热编码？

避免模型误认为类别之间有大小关系（例如“East”和“West”不能被解释为0 < 1）。
将类别信息转换为神经网络可以接受的二进制向量表示形式。
提高模型区分不同类别的能力。

📌 示例验证：

比如原始数据中有如下一列：

Neighborhood
East
West
North

经过独热编码后变成：

Neighborhood_East	Neighborhood_West	Neighborhood_North	Neighborhood_nan
1	0	0	0
0	1	0	0
0	0	1	0
0	0	0	1 (如果原值是 NaN)

这样每个类别都变成了独立的数值型特征列，便于模型学习。

🔍 建议改进（可选）：

如果希望未来避免手动调用 pd.get_dummies()，可以考虑使用更鲁棒的方式处理类别特征，例如：
使用 sklearn.preprocessing.OneHotEncoder（支持更多控制和保存编码器状态）
使用 torch.nn.Embedding（适用于大量类别或嵌入式编码）