从0开始机器学习--4.1编码和嵌入(语义计算方法，onehot独热、word2vec、node2vec、TFIDF，LabelEncoder等各类编码器库函数，含代码)

本文链接：https://blog.csdn.net/m0_73752612/article/details/142695572

写在前面

在上一篇中，我们了解了如何对数字形式的源数据做数据预处理，那现实生活中碰到的大多原始数据都是其他形式（如文字）的怎么办？当然也是转换成向量（数字）形式啦。毕竟到目前为止我认为机器学习的本质就是对向量进行各种运算和处理。这一篇文章也可以算是对《3.数据预处理》的延申，介绍one-hot、word2vec、node2vec。

当然，本文的标题也可起为“语义计算”，具体可见我的《自然语言处理nlp》专栏。

本文参考了其他博客：

1.python基础；
2.ai模型概念+基础；
3.数据预处理；
4.机器学习模型--1.编码（嵌入）；2.聚类；3.降维；4.回归（预测）；5.分类；
5.正则化技术；
6.神经网络模型--1.概念+基础；2.几种常见的神经网络模型；
7.对回归、分类模型的评价方式；
8.简单强化学习概念；
9.几种常见的启发式算法及应用场景；
10.机器学习延申应用-数据分析相关内容--1.A/B Test；2.辛普森悖论；3.蒙特卡洛模拟；
11.数据挖掘--关联规则挖掘
12.数学建模--决策分析方法，评价模型
13.主动学习（半监督学习）
以及其他的与人工智能相关的学习经历，如数据挖掘、计算机视觉-OCR光学字符识别、大模型等。

合集链接https://blog.csdn.net/m0_73752612/category_12799244.html?fromshare=blogcolumn&sharetype=blogcolumn&sharerId=12799244&sharerefer=PC&sharesource=m0_73752612&sharefrom=from_link

TF-IDF（Term Frequency-Inverse Document Frequency）

组成

1. 词频（TF，Term Frequency）

2. 逆文档频率（IDF，Inverse Document Frequency）

OrdinalEncoder（有序编码器）

BinaryEncoder（二进制编码器）

BaseNEncoder（N进制编码器）

FrequencyEncoder（频率编码器）

HashingEncoder（哈希编码器）

CountEncoder（计数编码器）

EmbeddingsEncoder（嵌入编码器）

原博客

总结

one-hot 编码

为什么使用 one-hot 编码？

问题

在机器学习算法中，我们经常会遇到分类特征，例如：人的性别有男女，祖国有中国，美国，法国等。这些特征值并不是连续的，而是离散的，无序的。

目的

如果要作为机器学习算法的输入，通常我们需要对其进行特征数字化。什么是特征数字化呢？例如：

性别特征：["男"，"女"]
祖国特征：["中国"，"美国，"法国"]
运动特征：["足球"，"篮球"，"羽毛球"，"乒乓球"]

瓶颈

假如某个样本（某个人），他的特征是 ["男","中国","乒乓球"] ，我们可以用 [0,0,4] 来表示，但是这样的特征处理并不能直接放入机器学习算法中。因为类别之间是无序的。

什么是 one-hot 编码？

定义

独热编码即 One-Hot 编码，又称一位有效编码。其方法是使用 N位状态寄存器来对 N个状态进行编码，每个状态都有它独立的寄存器位，并且在任意时候，其中只有一位有效。

理解

One-Hot 编码是分类变量作为二进制向量的表示。

将分类值映射到整数值。
然后，每个整数值被表示为二进制向量，除了整数的索引之外，它都是零值，它被标记为1。

举例1：
举个例子，假设我们有四个样本（行），每个样本有三个特征（列），如图：

上述feature_1有两种可能的取值，比如是男/女，这里男用1表示，女用2表示。feature_2 和 feature_3 各有4种取值（状态）。

one-hot 编码就是保证每个样本中的单个特征只有1位处于状态1，其他的都是0。

上述状态用 one-hot 编码如下图所示：

举例2：
按照 N位状态寄存器 来对N个状态进行编码的原理，处理后应该是这样的

性别特征：["男","女"] （这里只有两个特征，所以 N=2）：

男 => 10

女 => 01

祖国特征：["中国"，"美国，"法国"]（N=3）：

中国 => 100

美国 => 010

法国 => 001

运动特征：["足球"，"篮球"，"羽毛球"，"乒乓球"]（N=4）：

足球 => 1000

篮球 => 0100

羽毛球 => 0010

乒乓球 => 0001

所以，当一个样本为 ["男","中国","乒乓球"] 的时候，完整的特征数字化的结果为：

[1，0，1，0，0，0，0，0，1]

下图可能会更好理解：

python 代码示例：

from sklearn import preprocessing  
   
enc = preprocessing.OneHotEncoder()  
enc.fit([[0,0,3],[1,1,0],[0,2,1],[1,0,2]])  # 训练。这里共有4个数据，3种特征
   
array = enc.transform([[0,1,3]]).toarray()  # 测试。这里使用1个新数据来测试
   
print array   # [[ 1  0  0  1  0  0  0  0  1]] # 独热编码结果

以上对应关系可以解释为下图：

one-hot 编码优缺点？

优点

(1) 解决了分类器不好处理离散数据的问题。

a. 欧式空间。在回归，分类，聚类等机器学习算法中，特征之间距离计算或相似度计算是非常重要的，而我们常用的距离或相似度的计算都是在欧式空间的相似度计算，计算余弦相似性，基于的就是欧式空间。
b. one-hot 编码。使用 one-hot 编码，将离散特征的取值扩展到了欧式空间，离散特征的某个取值就对应欧式空间的某个点。将离散型特征使用 one-hot 编码，确实会让特征之间的距离计算更加合理。

(2) 在一定程度上也起到了扩充特征的作用。

缺点

在文本特征表示上有些缺点就非常突出了。

(1) 它是一个词袋模型，不考虑词与词之间的顺序（文本中词的顺序信息也是很重要的）；
(2) 它假设词与词相互独立（在大多数情况下，词与词是相互影响的）；
(3) 它得到的特征是离散稀疏的 (这个问题最严重)。

上述第3点展开：
(1) 为什么得到的特征是离散稀疏的？

例如，如果将世界所有城市名称作为语料库的话，那这个向量会过于稀疏，并且会造成维度灾难。如下：

杭州 [0,0,0,0,0,0,0,1,0,……，0,0,0,0,0,0,0]
上海 [0,0,0,0,1,0,0,0,0,……，0,0,0,0,0,0,0]
宁波 [0,0,0,1,0,0,0,0,0,……，0,0,0,0,0,0,0]
北京 [0,0,0,0,0,0,0,0,0,……，1,0,0,0,0,0,0]

在语料库中，杭州、上海、宁波、北京各对应一个向量，向量中只有一个值为1，其余都为0。

(2) 能不能把词向量的维度变小呢？

a) Dristributed representation：

可以解决 One hot representation 的问题，它的思路是:

1. 通过训练，将每个词都映射到一个较短的词向量上来。
2. 所有的这些词向量就构成了向量空间，
3. 进而可以用普通的统计学的方法来研究词与词之间的关系。

这个较短的词向量维度是多大呢？这个一般需要我们在训练时自己来指定。

b) 举例：

1. 比如将词汇表里的词用 "Royalty", "Masculinity", "Femininity" 和 "Age" 4个维度来表示，King 这个词对应的词向量可能是 (0.99,0.99,0.05,0.7)。

2. 在实际情况中，并不能对词向量的每个维度做一个很好的解释。

3. 将king这个词从一个可能非常稀疏的向量坐在的空间，映射到现在这个四维向量所在的空间，必须满足以下性质：

（1）这个映射是单射；
（2）映射之后的向量不会丢失之前的那种向量所含的信息。

4. 这个过程称为 word embedding（词嵌入），即将高维词向量嵌入到一个低维空间（会在《第四篇--降维》中具体介绍）。如图：

5. 经过我们一系列的降维神操作，有了用 representation 表示的较短的词向量，我们就可以较容易的分析词之间的关系了，比如我们将词的维度降维到 2维，有一个有趣的研究表明，用下图的词向量表示我们的词时，我们可以发现：

6. 出现这种现象的原因是，我们得到最后的词向量的训练过程中引入了词的上下文。举例：

想到得到 "learning" 的词向量，但训练过程中，你同时考虑了它左右的上下文，那么就可以使 "learning" 带有语义信息了。通过这种操作，我们可以得到近义词，甚至 cat 和它的复数 cats 的向量极其相近。

from sklearn.preprocessing import OneHotEncoder
import numpy as np

# 示例数据
categories = np.array(['cat', 'dog', 'fish']).reshape(-1, 1)

# 初始化并应用 One-Hot 编码
encoder = OneHotEncoder(sparse=False)
one_hot_encoded = encoder.fit_transform(categories)

print(one_hot_encoded)

输出：

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

word2vec嵌入

定义

word2vec就是word to vector的缩写，word2vec 也叫 word embeddings，中文名 “词向量”，作用就是将自然语言中的字词转为计算机可以理解的稠密向量（Dense Vector）。

功能

对于One-Hot 编码的维度灾难 (产生的是稀疏向量)，用 Vector Representations 可以有效解决这个问题。

(1) Word2Vec 可以将 One-Hot Encoder 转化为低维度的连续值，也就是稠密向量；

(2) 并且其中意思相近的词将被映射到向量空间中相近的位置。如果将 embed 后的城市向量通过 PCA 降维后可视化展示出来，那么结果如下。

模型

Word2Vec 模型其实就是简单化的神经网络（会在第六篇中具体介绍）。Word2Vec 方法由两部分组成。

首先是将高维独热形式表示的单词映射成低维向量。例如将 10，000 列的矩阵转换为 300 列的矩阵。这个过程被称为词嵌入。
第二个目标是在保留单词上下文的同时，从一定程度上保留其意义。

Input Layer：是 One-Hot Vector，
Hidden Layer： 没有激活函数，也就是线性的单元。这一层输出一个 dense vector，作为下一层的输入。
Output Layer：维度跟 Input Layer 的维度一样，用的是Softmax回归。

input layer —> hidden layer 网络的参数计算 (词嵌入过程)：

上图中，乘号右边的矩阵代表 hidden layer 的权重。设 input layer神经元数目(insize) 是 a ，hidden layer神经元数目 (outsize) 是 b ，weights数目 w，则有以下关系：w=a*b。因此，权重矩阵的维度是 a*b。
乘号左边的绿色的元素代表输入向量中的一个神经元，右边绿色的一行元素代表该输入神经元与 hidden layer所有神经元连接的一组weights。

下图是示例：

矩阵代表以上计算过程仍然存在缺点，因此被做简化。

缺点

我们来看一下上图中的矩阵运算，左边分别是1 x 5 和5 x 3 的矩阵，结果应该是1 x 3的矩阵，按照矩阵乘法的规则，结果的第一行第一列元素为0 x 17 + 0 x 23 + 0 x 4 + 1 x 10 + 0 x 11 = 10，同理可得其余两个元素为12，19。如果10000个维度的矩阵采用这样的计算方式是十分低效的。

解决

为了有效地进行计算，这种稀疏状态下不会进行矩阵乘法计算。上面的例子中，左边向量中取值为1的对应维度为3（下标从0开始），那么对应的就是矩阵的第3行（下标从0开始）—— [10, 12, 19]。这样模型中的隐层权重矩阵便成了一个“查找表”（lookup table）。进行矩阵计算时，直接去查输入向量中取值为1的维度下对应的那些权重值。隐层的输出就是每个输入单词的“嵌入词向量”。

分类

CBOW模式

定义：给定 上下文，来预测 input word。

应用：对 小型数据库 比较合适。

t 代表语句中的位置。

Skip-Gram模式

定义: 给定 input word 来预测上下文。

应用：在 大型语料 中表现更好。

例子：
对同样一个句子：Hangzhou is a nice city。如果要构造一个语境与目标词汇的映射关系，其实就是 input 与 label 的关系。

CBOW可以制造的映射关系为：[Hangzhou,a]—>is，[is,nice]—>a，[a,city]—>nice
Skip-Gram可以制造的映射关系为：(is,Hangzhou)，(is,a)，(a,is)， (a,nice)，(nice,a)，(nice,city)

其他博文：如何通俗理解Word2Vec (23年修订版)_word2vec_v_JULY_v-GitCode 开源社区 (csdn.net)

from gensim.models import Word2Vec

# 示例句子
sentences = [["cat", "chased", "the", "mouse"], ["dog", "barked"]]

# 训练 Word2Vec 模型
model = Word2Vec(sentences, vector_size=10, window=5, min_count=1, sg=0)

# 获取某个词的向量表示
word_vector = model.wv['cat']
print(word_vector)

输出：cat 的词向量表示（一个稠密向量）。

Word2Vec 的相似词是在训练数据中共享相似上下文的词，可能是：

同类别词（语义）
同语法角色词（句法）
共现词（关联性）
对立词（方向相反但上下文相似）

node2vec嵌入

目标

如何去把一张图来当作一篇文本，图中节点表示成文本中的 token。然后调用现成的 word2vec模型来生成向量。

瓶颈：而图不同于文本的特点是，文本是一个线性序列，图是一个复杂结构。

思路：使用 Skip-Gram 算法，其中

单词：将 node 作为单词；

句子：通过随机游走，得到 node 的序列，将这个序列作为句子。

改进：为了提高Skip-Gram的训练过程的效率，DeepWalk采用分层 softmax 的方法来训练。

1. 即将 node 分配到二叉树的叶节点上。

2. 在构造二叉树时，使用霍夫曼编码（数据结构中的概念），将使用频率高的节点放到较短的分支上。

这样算法复杂度（数据结构基础概念）就从O(|V|)降到了O(log|V|)。

概念：node2vec 通过改变随机游走序列的生成方式进一步扩展了DeepWalk 算法。

思路：DeepWalk 选取随机游走序列中下一个节点的方式是均匀随机分布的，而node2vec通过引入两个参数p和q，将 宽度先搜索 和 深度优先搜索（数据结构基础概念）引入随机游走序列的生成过程，来对图中的节点进行采样。如图所示。BFS 采样得到的是 Local microscopic view, 而DFS得到的是Global macrooscopoc view。

缺点（原博主的思考）：Link Prediction 是一个 Graph 问题，它的目标是根据已知的节点和边，得到新的边（的权值/特征）。目前nodevec的做法就好比，在一个社交网络上，只和其中很少一部分人建立了社交关系，剩下很多用户都没有关注。是否还有其他改进途径？

其他博文：

node2vec python 实现和理解_from node2vec import node2vec-CSDN博客

from node2vec import Node2Vec
import networkx as nx

# 创建简单图
G = nx.karate_club_graph()

# 初始化 Node2Vec
node2vec = Node2Vec(G, dimensions=10, walk_length=5, num_walks=50, workers=1)

# 训练模型
model = node2vec.fit(window=10, min_count=1)

# 获取某个节点的嵌入向量
node_vector = model.wv['1']
print(node_vector)

输出：节点 1 的向量表示。

在使用 node2vec 进行图嵌入时，结点的相似性既可能反映距离相近（同质性），也可能反映结构相似（结构性），具体取决于算法参数的配置（p 和 q）

参数 `p` 和 `q` 的影响

p 值小（如 p < 1）：倾向于 BFS（广度优先），捕获结构性相似（如 A 和 B，即使它们不相连）。
q 值小（如 q < 1）：倾向于 DFS（深度优先），捕获同质性相似（如 A 和 C）。
默认（p = q = 1）：等价于 DeepWalk，偏向同质性。

其他参数

dimensions：嵌入向量的维度（默认 128）。
walk_length：每条随机游走的长度（默认 30）。
- 随机游走：一种在图（或网络）上模拟“行走”的方法，从一个节点出发，按照一定的规则（如概率转移）逐步访问邻居节点，生成节点序列。
  - 无监督学习方式：不依赖标签。
  - 短游走（如 walk_length=10）捕获邻域信息（同质性）。
  - 长游走或多次游走捕获节点角色（结构性，如中心/边缘节点）。
num_walks：每个节点的随机游走次数（默认 200）。
workers：并行线程数（默认 1）。

一些对比：

GCN 是端到端的图深度学习模型，直接处理图结构和特征。
Node2Vec + CNN 是分阶段方法，先无监督学习嵌入，再用 CNN 处理，灵活性高但信息可能丢失。

TF-IDF（Term Frequency-Inverse Document Frequency）

是一种常用的文本处理技术、是一种特征提取方法，广泛应用于信息检索和文本挖掘中。它的主要目的是评估一个词在文档中的重要性。用于将文本数据转化为数值特征，使得文本可以被用于机器学习算法进行分类、聚类或回归任务。

组成

1. 词频（TF，Term Frequency）

指的是某个特定词在文档中出现的频率。词频越高，表示该词在文档中越重要。

2. 逆文档频率（IDF，Inverse Document Frequency）

反映某个词在所有文档中的普遍性。如果一个词在很多文档中都出现，其IDF值会较低，表明该词对文档区分度不高。

最终，TF-IDF值通过将TF和IDF相乘来计算：TF-IDF(t,d,D)=TF(t,d)×IDF(t,D)

应用

信息检索：用于计算文档与查询之间的相关性。
文本分类：帮助识别文本的主题。
关键词提取：自动从文本中提取关键词。

优点

能够有效地降低常见词（如“是”、“的”等）对文本分析的影响。
可以揭示出特定文档中的重要概念。

局限性

对于短文本，TF-IDF可能不够有效。
不考虑词的上下文和语义关系。

代码

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
docs = [
    "it is a good day, I like to stay here",
    "I am happy to be here", "I am bob",
    "it is sunny today", "I have a party today",
    "it is a dog and that is a cat",
    "there are dog and cat on the tree",
    "I study hard this morning",
    "today is a good day",
    "tomorrow will be a good day",
    "I like coffee, I like book and I like apple",
    "I do not like it", "I am kitty, I like bob",
    "I do not care who like bob, but I like kitty",
    "It is coffee time, bring your cup",
]
vectorizer = TfidfVectorizer() #使用sklearn计算tfidf的模型
tf_idf = vectorizer.fit_transform(docs) #.fit()函数训练模型， transform()：在fit的基础上，进行标准化，降维，归一化等操作（看具体用的是哪个工具，如PCA，StandardScaler等
#zip(vectorizer.idf_, vectorizer.get_feature_names_out())：将 IDF 值和特征名称一一对应打包成元组。
#[(n, idf) for idf, n in zip(vectorizer.idf_, vectorizer.get_feature_names_out())]：遍历打包后的元组，将每个特征名称和对应的 IDF 值组成元组，最终形成一个列表。
print("idf: ", [(n, idf) for idf, n in zip(vectorizer.idf_, vectorizer.get_feature_names_out())]) #提取idf的值
print("v2i: ", vectorizer.vocabulary_)#vectorizer.vocabulary_：这个属性是一个字典，将词汇映射到它们在特征矩阵中的索引。
q = "I get a coffee cup"
qtf_idf = vectorizer.transform([q]) #将query转换为tfidf 直接调用transform方法，使用之前使用fit_transform构建好的词汇表将查询句子q转换为TF-IDF向量表示。
res = cosine_similarity(tf_idf, qtf_idf) #计算query与模型的tfidf的余弦相似度
res = res.ravel().argsort()[-3:]#首先通过 ravel() 将多维数组展平成一维数组，然后通过 argsort() 对数组进行排序
print("\ntop 3 docs for '{}':\n{}".format(q, [docs[i] for i in res[::-1]]))#[::-1] 表示从开头到末尾以步长为 -1 的方式进行切片，即倒序
#使用 format() 方法将 q 和查询结果列表填充到模板中，并生成最终的字符串。
print( )

输出：

idf:  [('am', 2.386294361119891), ('and', 2.386294361119891), ('apple', 3.0794415416798357), ('are', 3.0794415416798357), ('be', 2.6739764335716716), ('bob', 2.386294361119891), ('book', 3.0794415416798357), ('bring', 3.0794415416798357), ('but', 3.0794415416798357), ('care', 3.0794415416798357), ('cat', 2.6739764335716716), ('coffee', 2.6739764335716716), ('cup', 3.0794415416798357), ('day', 2.386294361119891), ('do', 2.6739764335716716), ('dog', 2.6739764335716716), ('good', 2.386294361119891), ('happy', 3.0794415416798357), ('hard', 3.0794415416798357), ('have', 3.0794415416798357), ('here', 2.6739764335716716), ('is', 1.9808292530117262), ('it', 1.9808292530117262), ('kitty', 2.6739764335716716), ('like', 1.9808292530117262), ('morning', 3.0794415416798357), ('not', 2.6739764335716716), ('on', 3.0794415416798357), ('party', 3.0794415416798357), ('stay', 3.0794415416798357), ('study', 3.0794415416798357), ('sunny', 3.0794415416798357), ('that', 3.0794415416798357), ('the', 3.0794415416798357), ('there', 3.0794415416798357), ('this', 3.0794415416798357), ('time', 3.0794415416798357), ('to', 2.6739764335716716), ('today', 2.386294361119891), ('tomorrow', 3.0794415416798357), ('tree', 3.0794415416798357), ('who', 3.0794415416798357), ('will', 3.0794415416798357), ('your', 3.0794415416798357)]
v2i:  {'it': 22, 'is': 21, 'good': 16, 'day': 13, 'like': 24, 'to': 37, 'stay': 29, 'here': 20, 'am': 0, 'happy': 17, 'be': 4, 'bob': 5, 'sunny': 31, 'today': 38, 'have': 19, 'party': 28, 'dog': 15, 'and': 1, 'that': 32, 'cat': 10, 'there': 34, 'are': 3, 'on': 27, 'the': 33, 'tree': 40, 'study': 30, 'hard': 18, 'this': 35, 'morning': 25, 'tomorrow': 39, 'will': 42, 'coffee': 11, 'book': 6, 'apple': 2, 'do': 14, 'not': 26, 'kitty': 23, 'care': 9, 'who': 41, 'but': 8, 'time': 36, 'bring': 7, 'your': 43, 'cup': 12}

top 3 docs for 'I get a coffee cup':
['It is coffee time, bring your cup', 'I like coffee, I like book and I like apple', 'I do not care who like bob, but I like kitty']

编码器库函数

数值型变量通常不需要加入到 categorical_cols 列表中。除非想做某种离散化操作（例如，将它们转换为区间类别）

categorical_cols 列表通常用于存储那些分类特征（即离散的、具有有限取值的变量）。例如，像颜色、水果等列是分类特征，它们的值会在不同的实例之间不同，但值的范围有限，因此适合进行标签编码。

对于 days日期值这类数值型特征，它们更适合用于模型输入而不是作为类别编码的对象。如果把它们加到 categorical_cols 中，编码器会把它们视为类别变量进行编码，这并不符合它们的实际含义和处理方式。

LabelEncoder（标签编码器）

场景：用于将类别标签转换为整数。

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
encoded_labels = le.fit_transform(["红", "蓝", "绿", "红", "绿"])
print(encoded_labels)  # 输出：[2 0 1 2 1]

OneHotEncoder（独热编码器）

场景：将每个类别转换为一个独立的二进制列，适用于无序类别。

from sklearn.preprocessing import OneHotEncoder
enc = OneHotEncoder()
encoded = enc.fit_transform([["红"], ["蓝"], ["绿"]]).toarray()
print(encoded)  # 输出：[[1. 0. 0.]
                 #          [0. 1. 0.]
                 #          [0. 0. 1.]]

TargetEncoder（目标编码器）

场景：将类别特征映射到目标变量的均值。适用于目标变量与类别特征之间有关系的情况。

import category_encoders as ce
data = pd.DataFrame({
    '类别': ['红', '蓝', '绿', '红'],
    '目标': [1, 0, 1, 0]
})
encoder = ce.TargetEncoder(cols=['类别'])
data['类别编码'] = encoder.fit_transform(data['类别'], data['目标'])
print(data)
# 输出：
# 类别  目标  类别编码
# 红   1   0.5
# 蓝   0   0.0
# 绿   1   1.0
# 红   0   0.5

OrdinalEncoder（有序编码器）

场景：将具有自然顺序的类别映射为整数。适用于有序类别（如评分、等级等）。

from sklearn.preprocessing import OrdinalEncoder
oe = OrdinalEncoder(categories=[["低", "中", "高"]])
encoded = oe.fit_transform([["中"], ["低"], ["低"], ["高"]])
print(encoded)  # 输出：[[1.] [0.] [0.] [2.]]

BinaryEncoder（二进制编码器）

场景：用于类别数目较多的情况，将类别转换为二进制数，降低维度。

import category_encoders as ce
data = pd.DataFrame({"颜色": ["红", "蓝", "绿", "黄", "紫"]})
encoder = ce.BinaryEncoder(cols=["颜色"])
encoded = encoder.fit_transform(data["颜色"])
print(encoded)
# 输出：
#    颜色_0  颜色_1  颜色_2
# 0     0     0     0
# 1     1     0     0
# 2     0     1     0
# 3     1     1     0
# 4     0     0     1

BaseNEncoder（N进制编码器）

场景：类似于二进制编码，但是可以选择其他进制（如 3 进制、4 进制等）来编码类别。

import category_encoders as ce
data = pd.DataFrame({"颜色": ["红", "蓝", "绿", "黄"]})
encoder = ce.BaseNEncoder(cols=["颜色"], base=3)
encoded = encoder.fit_transform(data["颜色"])
print(encoded)
# 输出：
#    颜色_0  颜色_1
# 0     0     0
# 1     1     0
# 2     2     0
# 3     0     1

FrequencyEncoder（频率编码器）

场景：将类别编码为该类别在数据中出现的频率，适用于类别频率差异大的场景。

import category_encoders as ce
data = pd.DataFrame({"颜色": ["红", "蓝", "红", "绿", "蓝"]})
encoder = ce.CountEncoder(cols=["颜色"])
encoded = encoder.fit_transform(data["颜色"])
print(encoded)
# 输出：
#    颜色
# 0     2
# 1     2
# 2     2
# 3     1
# 4     2

HashingEncoder（哈希编码器）

场景：适用于类别数目非常多的情况，通过哈希函数将类别映射为低维向量，避免维度过高。

import category_encoders as ce
data = pd.DataFrame({"颜色": ["红", "蓝", "绿", "黄", "紫"]})
encoder = ce.HashingEncoder(cols=["颜色"], n_components=2)
encoded = encoder.fit_transform(data["颜色"])
print(encoded)
# 输出：
#    颜色_0  颜色_1
# 0    1    0
# 1    0    1
# 2    1    1
# 3    0    0
# 4    1    1

CountEncoder（计数编码器）

场景：将类别编码为它们在数据集中的出现次数。

import category_encoders as ce
data = pd.DataFrame({"颜色": ["红", "蓝", "红", "绿", "蓝"]})
encoder = ce.CountEncoder(cols=["颜色"])
encoded = encoder.fit_transform(data["颜色"])
print(encoded)
# 输出：
#    颜色
# 0     2
# 1     2
# 2     2
# 3     1
# 4     2

EmbeddingsEncoder（嵌入编码器）

场景：通过深度学习模型为类别特征生成低维稠密向量，常用于神经网络中处理具有大量类别的特征。

import torch
import torch.nn as nn

# 定义Embedding层
embedding = nn.Embedding(num_embeddings=10, embedding_dim=4)
# 输入数据
input_data = torch.tensor([1, 2, 3])
# 获取嵌入向量
encoded = embedding(input_data)

print(encoded)
# 输出：
# tensor([[ 0.7542, -1.0215, -0.7554, -0.4597],
#         [-0.0290,  0.3287,  0.3722, -0.2333],
#         [ 0.1817,  0.5810, -0.5825, -0.4853]],
#        grad_fn=<EmbeddingBackward>)

原博客

机器学习数据预处理1：独热编码（One-Hot）及其代码-CSDN博客

机器学习数据预处理2：词向量 (word2vec)_word2vec能用于机器学习吗-CSDN博客

机器学习数据预处理3：结点向量 (node2vec)_节点向量-CSDN博客

总结

One-Hot独热编码：将每个类别转换为一个长度为类别总数的二进制向量，向量中只有一个位置为1，其他位置为0，常用于分类任务中的特征表示。
Word2Vec：通过上下文预测词向量或根据词预测上下文，学习每个词的低维稠密向量表示，使得相似词的向量在语义空间中更接近，常用于自然语言处理任务。
Node2Vec：基于图结构的节点嵌入算法，通过随机游走生成节点的序列，然后使用类似 Word2Vec 的方法生成节点的向量表示，常用于网络分析或图上的节点分类任务。
TF-IDF 是文本特征提取方法，衡量词语在文档中的重要性，适用于信息检索和文本分类任务。
编码器：每种编码方法都有其适用的场景。