第N1周：one-hot编码

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊 | 接辅导、项目定制
• 🚀 文章来源：K同学的学习圈子

1.什么是one-hot编码

One-Hot编码是一种常用于机器学习中的特征编码方式，主要用于处理分类数据。它的基本思想是将分类变量转换为机器学习算法易于处理的形式。

假设你有一个数据集，其中有一个特征叫“颜色”，它有三个可能的值：红色、绿色和蓝色。在机器学习中，我们不能直接让算法处理这些文本值，因为算法需要数值型的数据。这时，One-Hot编码就可以派上用场了。

One-Hot编码的基本思想是为“颜色”这个特征中的每一个可能的值创建一个新的二进制列。在这个例子中，我们将为红色、绿色和蓝色分别创建三列。对于数据集中的每一行（即每一个样本），如果它的“颜色”是红色，那么我们在对应的“红色”列上标记为1，而在“绿色”和“蓝色”列上标记为0。同样地，如果颜色是绿色或蓝色，我们也按照相同的方式进行标记。

案例
假设我们有以下数据集：

序号 颜色
1 红色
2 绿色
3 蓝色
4 红色
使用One-Hot编码后，数据集将变为：

序号	红色	绿色	蓝色
1	1	0	0
2	0	1	0
3	0	0	1

可以看到，原来的“颜色”列被拆分成了三列，分别对应红色、绿色和蓝色。对于每一行，如果原始的颜色是红色，那么对应的“红色”列就是1，其他两列就是0；如果颜色是绿色或蓝色，也按照同样的规则进行标记。

2.为什么要使用One-Hot编码

1.易于处理：将分类数据转换为数值型数据后，机器学习算法就可以更容易地处理这些数据了。

2.避免引入不必要的顺序关系：如果只是简单地将颜色编码为数字（如红色=1，绿色=2，蓝色=3），那么算法可能会错误地认为红色与绿色的距离小于绿色与蓝色的距离，这显然是不合理的。而One-Hot编码则避免了这种不必要的顺序关系。

3.适用于多种算法：许多机器学习算法都接受数值型输入，而One-Hot编码可以将分类数据转换为这些算法可以接受的格式。

3.英文文本案例

import torch
import torch.nn.functional as F

#示例文本
texts = ['Hello, how are you? ','I am doing well, thank you! ','Goodbye.']

#构建词汇表
word_index = {}
index_word = {}
for i, word in enumerate(set("".join(texts).split())):
    word_index[word] = i
    index_word[i] = word
  
#将文本转化为整数序列
sequences = [[word_index[word]for word in text.split()] for text in texts]

#获取词汇表大小
vocab_size = len(word_index)

#将整数序列转化为one-hot编码
one_hot_results = torch.zeros(len(texts), vocab_size)
for i, seq in enumerate (sequences):
    one_hot_results[i,seq] = 1
    
#打印结果
print("词汇表：")
print(word_index)
print("\n文本：")
print(texts)
print("\n文本序列：")
print(sequences)
print("\nOne-Hot编码：")
print(one_hot_results)

词汇表： {‘well,’: 0, ‘thank’: 1, ‘you!’: 2, ‘how’: 3, ‘are’: 4, ‘Hello,’:
5, ‘am’: 6, ‘Goodbye.’: 7, ‘doing’: 8, ‘you?’: 9, ‘I’: 10}

文本： ['Hello, how are you? ', 'I am doing well, thank you! ',
‘Goodbye.’]

文本序列： [[5, 3, 4, 9], [10, 6, 8, 0, 1, 2], [7]]

One-Hot编码： tensor([[0., 0., 0., 1., 1., 1., 0., 0., 0., 1., 0.],
[1., 1., 1., 0., 0., 0., 1., 0., 1., 0., 1.],
[0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.]])

4.中文文本案例

import torch
import torch.nn.functional as F

#示例中文文本
texts = ['你好，最近怎么样？ ', '我过得很好，谢谢！', 'K同学啊']


#构建词汇表
word_index = {}
index_word = {}
for i, word in enumerate(set("".join(texts))):
    word_index[word] = i
    index_word[i] = word

#将文本转化为整数序列
sequences = [[word_index[word] for word in text] for text in texts]

#获取词汇表大小
vocab_size = len(word_index)

#将整数序列转化为one-hot编码
one_hot_results = torch.zeros(len(texts), vocab_size)
for i,seq in enumerate(sequences):
    one_hot_results[i,seq] = 1
    
#打印结果
print("词汇表：")
print(word_index)
print("\n文本：")
print(texts)
print("\n文本序列：")
print(sequences)
print("\nOne-Hot编码：")
print(one_hot_results)   

词汇表： {‘？’: 0, ‘，’: 1, ‘同’: 2, ‘近’: 3, ‘很’: 4, ‘我’: 5, ‘得’: 6, ‘啊’: 7,
‘怎’: 8, ‘过’: 9, ’ ': 10, ‘K’: 11, ‘么’: 12, ‘你’: 13, ‘好’: 14, ‘最’: 15,
‘样’: 16, ‘！’: 17, ‘学’: 18, ‘谢’: 19}

文本： ['你好，最近怎么样？ ', ‘我过得很好，谢谢！’, ‘K同学啊’]

文本序列： [[13, 14, 1, 15, 3, 8, 12, 16, 0, 10], [5, 9, 6, 4, 14, 1, 19,
19, 17], [11, 2, 18, 7]]

One-Hot编码： tensor([[1., 1., 0., 1., 0., 0., 0., 0., 1., 0., 1., 0.,
1., 1., 1., 1., 1., 0.,
0., 0.],
[0., 1., 0., 0., 1., 1., 1., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 1.,
0., 1.],
[0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.,
1., 0.]])

5.使用jieba分词案例

import torch
import torch.nn.functional as F
import jieba

#示例中文文本
texts = ['你好，最近怎么样？ ', '我过得很好，谢谢！', '再见。']

# 使用结巴分词进行分词
tokenized_texts = [list(jieba.cut(text)) for text in texts]

#构建词汇表
word_index = {}
index_word = {}
for i, word in enumerate(set([word for text in tokenized_texts for word in text])):
    word_index[word] = i
    index_word[i] = word

#将文本转化为整数序列
sequences = [[word_index[word] for word in text] for text in tokenized_texts]

#获取词汇表大小
vocab_size = len(word_index)

#将整数序列转化为one-hot编码
one_hot_results = torch.zeros(len(texts), vocab_size)
for i,seq in enumerate(sequences):
    one_hot_results[i,seq] = 1
    
#打印结果
print("词汇表：")
print(word_index)
print("\n文本：")
print(texts)
print("\n文本序列：")
print(sequences)
print("\nOne-Hot编码：")
print(one_hot_results)    

词汇表： {‘谢谢’: 0, ‘？’: 1, ‘好’: 2, ‘。’: 3, ’ ': 4, ‘很’: 5, ‘我过’: 6, ‘，’:
7, ‘你好’: 8, ‘得’: 9, ‘怎么样’: 10, ‘！’: 11, ‘最近’: 12, ‘再见’: 13}

文本： ['你好，最近怎么样？ ', ‘我过得很好，谢谢！’, ‘再见。’]

文本序列： [[8, 7, 12, 10, 1, 4], [6, 9, 5, 2, 7, 0, 11], [13, 3]]

One-Hot编码： tensor([[0., 1., 0., 0., 1., 0., 0., 1., 1., 0., 1., 0.,
1., 0.],
[1., 0., 1., 0., 0., 1., 1., 1., 0., 1., 0., 1., 0., 0.],
[0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])

6.任务

加载任务文件.txt文件并使用one-hot编码进行处理

import torch
import jieba
file_name = ".\任务文件.txt"
with open(file_name,"r",encoding = "utf-8") as file:
    context = file.read()
    sentences = context.split()
tokenized_texts = [list(jieba.lcut(sentence)) for sentence in sentences]
word_index = {}
index_word = {}
for i, word in enumerate(set([word for text in tokenized_texts for word in text])):
    word_index[word] = i
    index_word[i] = word
sequences = [[word_index[word] for word in text] for text in tokenized_texts]
vocab_size = len(word_index)
one_hot_results = torch.zeros(len(sentences), vocab_size)
for i,seq in enumerate(sequences):
    one_hot_results[i,seq] = 1

print("====词汇表:====\n", word_index)
print("====文本:====\n", sentences)
print("====分词结果:====\n", tokenized_texts)
print("====文本序列:====\n",sequences)
print("====One-Hot编码:====\n", one_hot_results)

词汇表: {‘模型’: 0, ‘为’: 1, ‘类别’: 2, ‘问题’: 3, ‘对于’: 4, ‘为了’: 5, ‘也’: 6, ‘是’: 7, ‘具有’: 8, ‘相互’: 9, ‘2’: 10, ‘表示’: 11, ‘hot’: 12, ‘但是’:
13, ‘或’: 14, ‘关系’: 15, ‘分别’: 16, ‘这种’: 17, ‘就是’: 18, ‘独立’: 19, ‘这些’:
20, ‘其余’: 21, ‘提到’: 22, ‘）’: 23, ‘地’: 24, ‘比较’: 25, ‘，’: 26, ‘1’: 27,
‘0’: 28, ‘可以’: 29, ‘one’: 30, ‘将’: 31, ‘了’: 32, ‘只有’: 33, ‘映射’: 34,
‘字典’: 35, ‘独热’: 36, ‘向量’: 37, ‘这样’: 38, ‘认为’: 39, ‘编码方式’: 40, ‘-’: 41,
‘称’: 42, ‘例如’: 43, ‘一个’: 44, ‘或者’: 45, ‘这’: 46, ‘上面’: 47, ‘。’: 48,
‘距离’: 49, ‘编码’: 50, ‘、’: 51, ‘元素’: 52, ‘错误’: 53, ‘一些’: 54, ‘可能’: 55,
‘基本’: 56, ‘序列’: 57, ‘：’: 58, ‘之间’: 59, ‘用’: 60, ‘实际上’: 61, ‘实际意义’: 62,
‘值’: 63, ‘采用’: 64, ‘到’: 65, ‘存在’: 66, ‘不’: 67, ‘使用’: 68, ‘思想’: 69,
‘每个’: 70, ‘三个’: 71, ‘引入’: 72, ‘和’: 73, ‘顺序’: 74, ‘情况’: 75, ‘有’: 76,
‘3’: 77, ‘的’: 78, ‘如下’: 79, ‘不同’: 80, ‘会’: 81, ‘（’: 82, ‘直观’: 83,
‘其中’: 84, ‘避免’: 85, ‘而’: 86}
文本: [‘比较直观的编码方式是采用上面提到的字典序列。例如，对于一个有三个类别的问题，可以用1、2和3分别表示这三个类别。但是，这种编码方式存在一个问题，就是模型可能会错误地认为不同类别之间存在一些顺序或距离关系，而实际上这些关系可能是不存在的或者不具有实际意义的。’,
‘为了避免这种问题，引入了one-hot编码（也称独热编码）。one-hot编码的基本思想是将每个类别映射到一个向量，其中只有一个元素的值为1，其余元素的值为0。这样，每个类别之间就是相互独立的，不存在顺序或距离关系。例如，对于三个类别的情况，可以使用如下的one-hot编码：’]
分词结果: [[‘比较’, ‘直观’, ‘的’, ‘编码方式’, ‘是’, ‘采用’, ‘上面’, ‘提到’, ‘的’, ‘字典’, ‘序列’, ‘。’, ‘例如’, ‘，’, ‘对于’, ‘一个’, ‘有’, ‘三个’, ‘类别’, ‘的’, ‘问题’,
‘，’, ‘可以’, ‘用’, ‘1’, ‘、’, ‘2’, ‘和’, ‘3’, ‘分别’, ‘表示’, ‘这’, ‘三个’, ‘类别’,
‘。’, ‘但是’, ‘，’, ‘这种’, ‘编码方式’, ‘存在’, ‘一个’, ‘问题’, ‘，’, ‘就是’, ‘模型’, ‘可能’,
‘会’, ‘错误’, ‘地’, ‘认为’, ‘不同’, ‘类别’, ‘之间’, ‘存在’, ‘一些’, ‘顺序’, ‘或’, ‘距离’,
‘关系’, ‘，’, ‘而’, ‘实际上’, ‘这些’, ‘关系’, ‘可能’, ‘是’, ‘不’, ‘存在’, ‘的’, ‘或者’,
‘不’, ‘具有’, ‘实际意义’, ‘的’, ‘。’], [‘为了’, ‘避免’, ‘这种’, ‘问题’, ‘，’, ‘引入’, ‘了’,
‘one’, ‘-’, ‘hot’, ‘编码’, ‘（’, ‘也’, ‘称’, ‘独热’, ‘编码’, ‘）’, ‘。’, ‘one’,
‘-’, ‘hot’, ‘编码’, ‘的’, ‘基本’, ‘思想’, ‘是’, ‘将’, ‘每个’, ‘类别’, ‘映射’, ‘到’,
‘一个’, ‘向量’, ‘，’, ‘其中’, ‘只有’, ‘一个’, ‘元素’, ‘的’, ‘值’, ‘为’, ‘1’, ‘，’,
‘其余’, ‘元素’, ‘的’, ‘值’, ‘为’, ‘0’, ‘。’, ‘这样’, ‘，’, ‘每个’, ‘类别’, ‘之间’,
‘就是’, ‘相互’, ‘独立’, ‘的’, ‘，’, ‘不’, ‘存在’, ‘顺序’, ‘或’, ‘距离’, ‘关系’, ‘。’,
‘例如’, ‘，’, ‘对于’, ‘三个’, ‘类别’, ‘的’, ‘情况’, ‘，’, ‘可以’, ‘使用’, ‘如下’, ‘的’,
‘one’, ‘-’, ‘hot’, ‘编码’, ‘：’]]
文本序列: [[25, 83, 78, 40, 7, 64, 47, 22, 78, 35, 57, 48, 43, 26, 4, 44, 76, 71, 2, 78, 3, 26, 29, 60, 27, 51, 10, 73, 77, 16, 11,
46, 71, 2, 48, 13, 26, 17, 40, 66, 44, 3, 26, 18, 0, 55, 81, 53, 24,
39, 80, 2, 59, 66, 54, 74, 14, 49, 15, 26, 86, 61, 20, 15, 55, 7, 67,
66, 78, 45, 67, 8, 62, 78, 48], [5, 85, 17, 3, 26, 72, 32, 30, 41, 12,
50, 82, 6, 42, 36, 50, 23, 48, 30, 41, 12, 50, 78, 56, 69, 7, 31, 70,
2, 34, 65, 44, 37, 26, 84, 33, 44, 52, 78, 63, 1, 27, 26, 21, 52, 78,
63, 1, 28, 48, 38, 26, 70, 2, 59, 18, 9, 19, 78, 26, 67, 66, 74, 14,
49, 15, 48, 43, 26, 4, 71, 2, 78, 75, 26, 29, 68, 79, 78, 30, 41, 12,
50, 58]]
One-Hot编码: tensor([[1., 0., 1., 1., 1., 0., 0., 1., 1., 0., 1., 1., 0., 1., 1., 1., 1., 1.,
1., 0., 1., 0., 1., 0., 1., 1., 1., 1., 0., 1., 0., 0., 0., 0., 0., 1.,
0., 0., 0., 1., 1., 0., 0., 1., 1., 1., 1., 1., 1., 1., 0., 1., 0., 1.,
1., 1., 0., 1., 0., 1., 1., 1., 1., 0., 1., 0., 1., 1., 0., 0., 0., 1.,
0., 1., 1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1.],
[0., 1., 1., 1., 1., 1., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 0., 1.,
1., 1., 0., 1., 0., 1., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0.,
1., 1., 1., 0., 0., 1., 1., 1., 1., 0., 0., 0., 1., 1., 1., 0., 1., 0.,
0., 0., 1., 0., 1., 1., 0., 0., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1.,
1., 0., 1., 1., 0., 0., 1., 1., 0., 0., 1., 0., 1., 1., 0.]])