Embedding

已于 2022-07-17 22:01:01 修改
阅读量812 收藏 2
点赞数
文章标签： 人工智能 机器学习
于 2022-07-16 21:59:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53430308/article/details/125815804
版权

1.来源及定义

embedding的出现是为了弥补one-hot在表示物品时的不足，当物品的数量变的很多时用one-hot表示的物品的向量就会变的很长，而且很稀疏，这不仅不利于存储而且对于神经网络的输入来说也是不适合的，另一个缺点就是one-hot向量不能很好的表示出两个物品之间的联系，因为任意两个向量的内积为0。

embedding的出现就弥补了这种不足，他将one-hot的高维稀疏向量转换成低维稠密向量，这不仅减少了神经网络的输入维度，而且利用两个向量之间的余弦相似度还能推算出这两个物品的相似度。

embedding和one-hot都是一种将我们人类总结出的抽象的表示的物品，转换成数值型的输入能被计算机所识别，也就是将它嵌入到一个数学空间中去。这也即词嵌入(word embedding)。下面我们要介绍词嵌入的一种方法-word2vec。

2.word2vec原理及代码

word2vec模型是谷歌在2013年提出的，这是一个生成对“词”的向量表达的模型。它有两种实现的方式CBOW和Skip-gram,如下图所示：

 其中CBOW模型是用上下文单词来预测中心单词，输入是这个词的上下文单词，输出是预测的词。

Skip-gram模型是用中心单词来预测上下文单词，输入是中心单词，输出是上下文单词。

而在模型之中，这些单词的初始输入是用one-hot向量表示的，而你可能要说：我们如何确定上下文单词的数量哪？这个时候就要引出模型中的滑动窗口的概念了，它规定了我们要预测的上下文单词的数量。例如说滑动窗口为1，就是认为中心单词之和他的前后两个单词有关，那么这个窗口之中总共就会有三个单词，如果使用的是Skip-gram模型，那么输入的就是中心这个单词的one-hot向量，输出就是预测的上下文两个单词的概率。

因为我们的目标是去预测一个词，我们就希望这个词出现的概率最大，我们用p(w_{t+j}|w_{t})来表示一个词出现的概率，也就是希望这些概率之积最大，word2vec的目标函数是：

 其中c是滑动窗口的大小，t代表这一时刻的输入。下面我们就是要如何定义p(w_{t+j}|w_{t})，作为一个多分类问题，最直接的方法就是使用softmax函数，word2vec的“愿景”是用一个词向量v_{w}表示词w用词之间的内积距离v_{i}^{T}v_{j}表示语义的接近程度因此概率被定义为：

 其中w_{o}代表w_{t+j}表示输出词，w_{i}代表w_{t}称为输入词。

下面我们以代码为例子来讲解Skip-gram模型，其中代码包括一下几个部分：

1.数据的准备和超参数的设定

2.模型的训练

3.模型的使用

我们先看第一步：

settings = {
    'window_size': 2,   #窗口尺寸 m
    #单词嵌入(word embedding)的维度,维度也是隐藏层的大小。
    'n': 10,
    'epochs': 50,         #表示遍历整个样本的次数。在每个epoch中，我们循环通过一遍训练集的样本。
    'learning_rate':0.01 #学习率
}


text = "natural language processing and machine learning is fun and exciting"

这里给出了训练时的超参数例如，窗口大小为2表示训练时寻找目标单词前后两个单词，也就是窗口中一共有5个单词。嵌入的维度也就是最后单词的embedding向量有十项。

text = "natural language processing and machine learning is fun and exciting"

这是我们输入的一个句子，接下来要把每个不同的单词都转换成one-hot向量表示。

def word2onehot(self, word):
 
        #将词用onehot编码
 
        word_vec = [0 for i in range(0, self.v_count)]     #生成一个大小为v_count的全为0的列表
 
        word_index = self.word_index[word]         #索引词得到序号，将他的那一项置为1
 
        word_vec[word_index] = 1
 
        return word_vec

这是一个将输入进来的单词转换成one-hot向量的函数，首先就是生成一个全为0的列表，他的大小为句子中不重复单词的个数，然后得到这个单词的索引，将它对应的列表的位置置1得到它的one-hot向量。

    def generate_training_data(self, settings, corpus):
        """
        得到训练数据
        """
 
        #defaultdict(int)  一个字典，当所访问的键不存在时，用int类型实例化一个默认值
        word_counts = defaultdict(int)
 
        #遍历语料库corpus
        for row in corpus:
            for word in row:
                #统计每个单词出现的次数
                word_counts[word] += 1
        #print(word_counts)
        # 词汇表的长度，不重复单词的长度
        self.v_count = len(word_counts.keys())
        # 在词汇表中的单词组成的列表
        self.words_list = list(word_counts.keys())
        # 以词汇表中单词为key，索引为value的字典数据
        self.word_index = dict((word, i) for i, word in enumerate(self.words_list))        #enumerate函数返回序号和对应的内容相当于range(len(list))
        #以索引为key，以词汇表中单词为value的字典数据
        self.index_word = dict((i, word) for i, word in enumerate(self.words_list))
 
        training_data = []
 
        for sentence in corpus:
            sent_len = len(sentence)
            print(sentence)
            print("%%%%")
            for i, word in enumerate(sentence):
 
                w_target = self.word2onehot(sentence[i])
 
                w_context = []
 
                for j in range(i - self.window, i + self.window):    #得到中心单词本身和他前后两个单词的编码，取不到最后一个
                    if j != i and j <= sent_len - 1 and j >= 0:
                        w_context.append(self.word2onehot(sentence[j]))
                
                training_data.append([w_target, w_context])          #训练数据第一个为其自身的编码，第二个为他相邻词的编码
 
        return np.array(training_data)

这是对训练数据的处理，首先创建一个字典统计每个单词出现的次数，然后得到这个列表的长度。

之后得到每个单词的one-hot向量表示，然后将一个窗口里的单词的one-hot向量放在一起组成一个训练样本，其中中心词的向量为一个列表，背景词的向量为一个列表。但这里因为for循环取不到最后一个单词所以窗口内最大有四个单词。

[[list([1, 0, 0, 0, 0, 0, 0, 0, 0]) list([[0, 1, 0, 0, 0, 0, 0, 0, 0]])]
 [list([0, 1, 0, 0, 0, 0, 0, 0, 0])
  list([[1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0]])]
 [list([0, 0, 1, 0, 0, 0, 0, 0, 0])
  list([[1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0]])]
 [list([0, 0, 0, 1, 0, 0, 0, 0, 0])
  list([[0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0]])]
 [list([0, 0, 0, 0, 1, 0, 0, 0, 0])
  list([[0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0]])]
 [list([0, 0, 0, 0, 0, 1, 0, 0, 0])
  list([[0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0]])]
 [list([0, 0, 0, 0, 0, 0, 1, 0, 0])
  list([[0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0]])]
 [list([0, 0, 0, 0, 0, 0, 0, 1, 0])
  list([[0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0]])]
 [list([0, 0, 0, 1, 0, 0, 0, 0, 0])
  list([[0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1]])]
 [list([0, 0, 0, 0, 0, 0, 0, 0, 1])
  list([[0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0]])]]

这是处理完后的所有的训练样本，其中第一行为一个训练样本，第一个list表示中心词的向量表示，第二个list为背景词的向量表示，因为第一个词只有后边才有相邻的词，而我们的循环中又少取了一个单词，所以说第一个训练样本只有两个向量，下面的情况类似。

    def train(self, training_data):
 
 
        #随机化参数w1,w2
        self.w1 = np.random.uniform(-1, 1, (self.v_count, self.n))
 
        self.w2 = np.random.uniform(-1, 1, (self.n, self.v_count))

        for i in range(self.epochs):
 
            self.loss = 0
 
            # w_t 是表示目标词的one-hot向量
            #w_t -> w_target,w_c ->w_context
            for w_t, w_c in training_data:

                #前向传播
                y_pred, h, u = self.forward(w_t)
                #print(y_pred)
                #计算误差
                EI = np.sum([np.subtract(y_pred, word) for word in w_c], axis=0)
                
                #反向传播，更新参数
                self.backprop(EI, h, w_t)
 
                #计算总损失
                self.loss += -np.sum([u[word.index(1)] for word in w_c]) + len(w_c) * np.log(np.sum(np.exp(u)))         #索引1元素所在的位置
                #for word in w_c:
                #   print(word.index(1))
            print('Epoch:', i, "Loss:", self.loss)

这是训练的过程，首先初始化隐藏层和输出层的权重矩阵，然后对于每一轮训练，首先从训练数据中选取一个中心词向量和背景词向量，将中心词的向量输入到神经网络中，得到预测的输出，然后计算它和真实输出也就是背景词的向量的差值进行累加，然后反向传播更新梯度，记录每一轮的总损失，然后输出。

def forward(self, x):
        """
        前向传播
        """
        #print("######")
        #print(self.w1.T)
        #print(type(self.w1.T))
        #print(x)
        #print(type(x))
        h = np.dot(self.w1.T, x)     #x:1*9   w1.T:10*9     h:1*10   数组和列表相乘，数组的每一行和列表的对应位置相乘得到第一个数，符合矩阵乘法时执行矩阵乘法
        #print(h)
        #print(type(h))
        u = np.dot(self.w2.T, h)     #w2.T:9*10  h:1*10     u:1*9
 
        y_c = self.softmax(u)
 
        return y_c, h, u

这是前项传播的过程，其中要注意在做矩阵的乘法时用到了矩阵的广播运算，即让矩阵的一行和另一个矩阵的一行相乘，最终的输出用softmax函数来归一化表示概率，这和上面理论推导的公式是一致的。

    def softmax(self, x):
        """
        """
        e_x = np.exp(x - np.max(x))
 
        return e_x / np.sum(e_x)

softmax函数的定义。

   def backprop(self, e, h, x):
 
        d1_dw2 = np.outer(h, e)              
        d1_dw1 = np.outer(x, np.dot(self.w2, e.T))
 
        self.w1 = self.w1 - (self.lr * d1_dw1)
        self.w2 = self.w2 - (self.lr * d1_dw2)

反向传播梯度的更新。(这里感觉反向传播时用的是交叉熵损失函数吗？但是训练时的损失为啥为y_pred-yword)。可能是没标出来。。。

因为交叉熵损失对于多分类问题的梯度就是这样，可以看【深度学习】：超详细的Softmax求导_BQW_的博客-CSDN博客_softmax的导数

    def vec_sim(self, word, top_n):
        """
        找相似的词
        """
 
        v_w1 = self.word_vec(word)
        word_sim = {}
 
        for i in range(self.v_count):
            v_w2 = self.w1[i]
            theta_sum = np.dot(v_w1, v_w2)
 
            #np.linalg.norm(v_w1) 求范数 默认为2范数，即平方和的二次开方   余弦相似度
            theta_den = np.linalg.norm(v_w1) * np.linalg.norm(v_w2)
            theta = theta_sum / theta_den
 
            word = self.index_word[i]
            word_sim[word] = theta
 
        words_sorted = sorted(word_sim.items(), key=lambda kv: kv[1], reverse=True)
 
        for word, sim in words_sorted[:top_n]:
            print(word, sim)

Skip-gram模型实际上是为了得到w1矩阵(其实也可以用w2矩阵来代表词向量)，这个矩阵的每一行就代表了一个单词的嵌入向量。所以查找出两个单词之间的向量然后计算他们的余弦相似度就可以找到相似的单词了。 

总的代码：

import numpy as np
from collections import defaultdict
 
 
class word2vec():
 
    def __init__(self):
        self.n = settings['n']
        self.lr = settings['learning_rate']
        self.epochs = settings['epochs']
        self.window = settings['window_size']
 
    def generate_training_data(self, settings, corpus):
        """
        得到训练数据
        """
 
        #defaultdict(int)  一个字典，当所访问的键不存在时，用int类型实例化一个默认值
        word_counts = defaultdict(int)
        print(word_counts)
        #遍历语料库corpus
        for row in corpus:
            for word in row:
                #统计每个单词出现的次数
                word_counts[word] += 1
        #print(word_counts)
        # 词汇表的长度，不重复单词的长度
        self.v_count = len(word_counts.keys())
        # 在词汇表中的单词组成的列表
        self.words_list = list(word_counts.keys())
        # 以词汇表中单词为key，索引为value的字典数据
        self.word_index = dict((word, i) for i, word in enumerate(self.words_list))        #enumerate函数返回序号和对应的内容相当于range(len(list))
        #以索引为key，以词汇表中单词为value的字典数据
        self.index_word = dict((i, word) for i, word in enumerate(self.words_list))
 
        training_data = []
 
        for sentence in corpus:
            sent_len = len(sentence)
            print(sentence)
            print("%%%%")
            for i, word in enumerate(sentence):
 
                w_target = self.word2onehot(sentence[i])
 
                w_context = []
 
                for j in range(i - self.window, i + self.window):    #得到中心单词本身和他前后两个单词的编码，取不到最后一个
                    if j != i and j <= sent_len - 1 and j >= 0:
                        w_context.append(self.word2onehot(sentence[j]))
                
                training_data.append([w_target, w_context])          #训练数据第一个为其自身的编码，第二个为他相邻词的编码
 
        return np.array(training_data)
 
    def word2onehot(self, word):
 
        #将词用onehot编码
 
        word_vec = [0 for i in range(0, self.v_count)]     #生成一个大小为v_count的全为0的列表
 
        word_index = self.word_index[word]         #索引词得到序号，将他的那一项置为1
 
        word_vec[word_index] = 1
 
        return word_vec
 
    def train(self, training_data):
 
 
        #随机化参数w1,w2
        self.w1 = np.random.uniform(-1, 1, (self.v_count, self.n))
 
        self.w2 = np.random.uniform(-1, 1, (self.n, self.v_count))

        for i in range(self.epochs):
 
            self.loss = 0
 
            # w_t 是表示目标词的one-hot向量
            #w_t -> w_target,w_c ->w_context
            for w_t, w_c in training_data:

                #前向传播
                y_pred, h, u = self.forward(w_t)
                #print(y_pred)
                #计算误差
                EI = np.sum([np.subtract(y_pred, word) for word in w_c], axis=0)
                
                #反向传播，更新参数
                self.backprop(EI, h, w_t)
 
                #计算总损失
                self.loss += -np.sum([u[word.index(1)] for word in w_c]) + len(w_c) * np.log(np.sum(np.exp(u)))         #索引1元素所在的位置
                #for word in w_c:
                #   print(word.index(1))
            print('Epoch:', i, "Loss:", self.loss)
  
    def forward(self, x):
        """
        前向传播
        """
        #print("######")
        #print(self.w1.T)
        #print(type(self.w1.T))
        #print(x)
        #print(type(x))
        h = np.dot(self.w1.T, x)     #x:1*9   w1.T:10*9     h:1*10   数组和列表相乘，数组的每一行和列表的对应位置相乘得到第一个数，符合矩阵乘法时执行矩阵乘法
        #print(h)
        #print(type(h))
        u = np.dot(self.w2.T, h)     #w2.T:9*10  h:1*10     u:1*9
 
        y_c = self.softmax(u)
 
        return y_c, h, u
 
 
    def softmax(self, x):
        """
        """
        e_x = np.exp(x - np.max(x))
        #print(np.max(x))
        return e_x / np.sum(e_x)
 
 
    def backprop(self, e, h, x):
 
        d1_dw2 = np.outer(h, e)              
        d1_dw1 = np.outer(x, np.dot(self.w2, e.T))
 
        self.w1 = self.w1 - (self.lr * d1_dw1)
        self.w2 = self.w2 - (self.lr * d1_dw2)
 
    def word_vec(self, word):
 
        """
        获取词向量
        通过获取词的索引直接在权重向量中找
        """
 
        w_index = self.word_index[word]
        v_w = self.w1[w_index]
 
        return v_w
 
    def vec_sim(self, word, top_n):
        """
        找相似的词
        """
 
        v_w1 = self.word_vec(word)
        word_sim = {}
 
        for i in range(self.v_count):
            v_w2 = self.w1[i]
            theta_sum = np.dot(v_w1, v_w2)
 
            #np.linalg.norm(v_w1) 求范数 默认为2范数，即平方和的二次开方   余弦相似度
            theta_den = np.linalg.norm(v_w1) * np.linalg.norm(v_w2)
            theta = theta_sum / theta_den
 
            word = self.index_word[i]
            word_sim[word] = theta
 
        words_sorted = sorted(word_sim.items(), key=lambda kv: kv[1], reverse=True)
 
        for word, sim in words_sorted[:top_n]:
            print(word, sim)
 
    def get_w(self):
        w1 = self.w1
        return  w1
#超参数
settings = {
    'window_size': 2,   #窗口尺寸 m
    #单词嵌入(word embedding)的维度,维度也是隐藏层的大小。
    'n': 10,
    'epochs': 50,         #表示遍历整个样本的次数。在每个epoch中，我们循环通过一遍训练集的样本。
    'learning_rate':0.01 #学习率
}
 
#数据准备
text = "natural language processing and machine learning is fun and exciting"
#按照单词间的空格对我们的语料库进行分词,并转换成小写
corpus = [[word.lower() for word in text.split()]]
print(corpus)
 
#初始化一个word2vec对象
w2v = word2vec()
 
training_data = w2v.generate_training_data(settings,corpus)
print(training_data)
#训练
w2v.train(training_data)
print("######")
print(w2v.w1)
# 获取词的向量
word = "machine"
vec = w2v.word_vec(word)
print(word, vec)
 
# 找相似的词
w2v.vec_sim("machine", 3)

3.总结

对于CBOW模型只是选择的中心词不一样，也就是输入数据时输入数据的list为多个向量而中心单词的list只有一个向量。前向传播的过程为将每个中心词分别输入到网络中得到几个输入，用这几个输入和同一个背景词做误差，反向传播更新参数。

参考博客：
Word2vec代码实现_SUNNY小飞的博客-CSDN博客_word2vec代码实现

4.补充

4.1.item2vec

既然词语能用嵌入向量来表示，而在实际的推荐中我们接触到的数据大多都是一个用户和物品序列，能不能对这些东西进行嵌入式向量表示哪？

为此微软在2016年提出了计算物品Embedding向量的方法 Item2vec.

item2vec就是将用户的物品交互的序列看作是一个词序列然后，将他作为输入得到物品的嵌入向量。它利用的物品的序列是由特定用户的浏览，购买等行为产生的历史行为记录序列。他的优化目标如下：

 其中K代表用户，w代表物品和Skip-gram中的词类似。

你会发现它和word2vec相比最大的不同在于缺少了时间窗口，它认为序列中任意两个物品都相关，因此它计算的概率是这一个物品和其他所有物品的概率，其他的训练过程都和word2vec相同。

在得到物品的Embedding之后我们可以简单的对他取平均作为用户的Embedding。

4.2.Graph Embedding

前面提到的word和item都是一种序列样本，但在互联网场景下，数据对象之间更多的呈现出图结构，如知识图谱等，如何对图的这些节点生成嵌入向量，这是一个值得研究的问题。

下面我们介绍一种deepwalk算法，他是一种图嵌入的方法之一，他的基本思想是在物品构成的关系图中随机游走产生许多物品的序列，将这些序列作为word2vec的样本输入，得到物品的嵌入向量。

这幅图很好的展示了deepwalk的算法流程，首先a是用户对于物品的交互的序列，b是构建的物品关系图，从A到B有一条有向边表示用户先后购买了物品A和物品B。

接下来就是随机游走生成大量的序列样本，然后输入到word2vec中进行训练。

在随机游走的生成算法

 上图展示了deepwalk算法的过程，可以看到随机游走的序列的长度是设定好的为t。w是skip-gram模型中的窗口大小，d是生成的嵌入向量的维度。

第二步是构建一个二叉树关于顶点V。

第三步\gamma定义了循环的次数，即对每个顶点做随机游走的次数。

第四步打乱顶点的顺序。

第五步之后对于每个顶点，采用一次随机游走，将生成的序列输入到skip-gram模型中。

这里的代码对应算法流程里的第六行

def deepwalk_walk(self, walk_length, start_node):

    walk = [start_node]     #生成的walk序列

    while len(walk) < walk_length:  
        cur = walk[-1]      #取最后一个当作起始节点
        cur_nbrs = list(self.G.neighbors(cur))  #获取它的邻居节点
        if len(cur_nbrs) > 0:
            walk.append(random.choice(cur_nbrs))   #将他添加到列表中
        else:
            break
    return walk

这里的代码对应第三行的外层循环

def _simulate_walks(self, nodes, num_walks, walk_length,):
    walks = []
    for _ in range(num_walks):
        random.shuffle(nodes)  #打乱所有的节点
        for v in nodes:           
            walks.append(self.deepwalk_walk(alk_length=walk_length, start_node=v)) 
            #将这个节点输入到deepwalk算法中，得到一个序列
    return walks

最后还要说明一下当到达一个顶点后是如何跳转到下一个顶点的，我们定义这样一个公式来表示节点Vi到节点Vj的概率：

\varepsilon表示物品关系图中所有边的集合，N_{+}(v_{i})是节点v_{i}的所有出边的集合M_{ij}是节点v_{i}到节点v_{j}边的权重，这个概率就被表述为要跳转的边的权重占所有出边的权重的比例。对于无权无向图，M_{ij}=1，此时的边也不再分为出边和入边了。

当然跳转概率也可以被定义为是均等的。

qq_53430308
关注
myEmb_embedding_
10-03
在IT领域，嵌入（Embedding）是一种将非结构化数据转换为低维向量空间中的数值表示的技术，常用于自然语言处理、图论和推荐系统等。在本项目"myEmb_embedding_"中，我们将探讨如何对网络数据，特别是用networkx库...
什么是embedding？
热门推荐
weixin_44493841的博客
07-10 10万+
本文转自：https://www.jianshu.com/p/6c977a9a53de 　　 简单来说，embedding就是用一个低维的向量表示一个物体，可以是一个词，或是一个商品，或是一个电影等等。这个embedding向量的性质是能使距离相近的向量对应的物体有相近的含义，比如 Embedding(复仇者联盟)和Embedding(钢铁侠)之间的距离就会很接近，但 Embedding(复仇者联...
Embedding 基础
Edward_Legend的博客
11-21 2万+
一、什么是Embedding 简单来说，Embedding 就是用一个数值向量“表示”一个对象（Object）的方法，这里说的对象可以是一个词、一个物品，也可以是一部电影等等。一个物品能被向量表示，是因为这个向量跟其他物品向量之间的距离反映了这些物品的相似性。更进一步来说，两个向量间的距离向量甚至能够反映它们之间的关系。这个解释听上去可能还是有点抽象，那我们再用两个具体的例子解释一下。 上图是 Google 著名的论文 Word2vec 中的例子，它利用 Word2vec 这个模型把单词映射到了高维空间中
神经网络算法 - 一文搞懂Embedding（嵌入）
2401_85328934的博客
08-22 1940
本文将从三个方面，带您一文搞懂Embedding（嵌入）原理：将离散数据映射为连续向量，捕捉潜在关系。方法：使用神经网络中的Embedding层，训练得到数据的向量表示。作用：提升模型性能，增强泛化能力，降低计算成本。在机器学习中，Embedding主要是指将离散的高维数据（如文字、图片、音频）映射到低维度的连续向量空间。这个过程会生成由实数构成的向量，用于捕捉原始数据的潜在关系和结构。原理：将文本转换为连续向量，基于分布式假设捕捉语义信息。
深度学习中Embedding的解释
yuanmiyu6522的博客
10-24 2万+
转载于https://zhuanlan.zhihu.com/p/164502624 什么是Embedding？近年来，NLP自然语言处理、推荐系统，以及计算机视觉已成为目前工业界算法岗的主流方向，无论在哪个领域，对“Embedding”这个词概念的理解都是每个庞大知识体系的基石。今天我们就以诙谐生动的方式来理解一下这个看似高大上的名词吧。“Embedding”直译是嵌入式、嵌入层。看到这个翻译的时候是不是一脸懵圈？什么叫嵌入？意思是牢固地或深深地固定？那么它能把什么嵌入到什么呢？很开心地告诉你，它能把万物.
【文本分类】深入理解embedding层的模型、结构与文本表示
十一月廿七风雨大作
12-09 1万+
深入理解embedding层的模型、结构与文本表示
embedding理解.pdf
04-08
### 知识点详解：深度学习中的嵌入（Embedding）技术 #### 一、什么是嵌入（Embedding） 在深度学习领域，**嵌入**（Embedding）是指一种将离散变量映射到连续向量空间的方法。这种技术特别适用于处理分类数据，...
embedding
03-21
嵌入存储库要记住的定义属性-对象（人，物等）的特征。变量-逻辑属性集。可能是依赖的或独立的。因变量-在某些定律或规则（例如，通过数学函数）下，它们的值取决于其他变量的值的假设或假设下，对其值进行研究。...
pytorch中的embedding词向量的使用方法
09-18
PyTorch作为一个流行的深度学习框架，提供了丰富的API来处理词向量，特别是通过Embedding模块来支持这些操作。本文将详细介绍如何在PyTorch中使用embedding词向量。 首先，要使用PyTorch中的embedding词向量，需要...
基于luotuo大语言模型的embedding方法
06-27
应用于向量搜素，文本匹配，文本聚类 ，少样本的分类学习，文本数据可视化，效果相比于传统的方法性能大幅度提升
深度学习embedding方法，降维，以及pytorch中使用embedding
weixin_41106546的博客
04-24 5468
形式上讲，Embedding就是用。
神经网络算法：一文搞懂 Embedding（嵌入）
2401_84033492的博客
04-02 4132
本文将从Embedding的本质、Embedding的原理、Embedding的应用三个方面，带您一文搞懂Embedding（嵌入）。
【文本特征表征（1）】什么是embedding（把物体编码为一个低维稠密向量）pytorch中nn.Embedding原理及使用，大模型的LMAS.Embedding原理及使用
Hali_Botebie的博客
06-15 1万+
使embedding空前流行的“word2vec”到了深度学习时代，我们一定会首先想到 2013 年的 Word2Vec——没错，句子是由词构成的，有了词向量，句子向量自然而然呼之欲出了。直觉看，直接对每个词的向量拼接、求和、逐元素相乘、取平均值或最大值，得到的向量都可以表示为句子向量。当然，这里面也有一些花样，比如加权重求和：权重可以根据词性、句法结构等设定一个固定值，然后对每个位置的词向量乘权重再求和；权重也可以根据输入向量来，输出向量的_每个元素_都根据输入元素向量进行加权求和。
【Transformer系列】深入浅出理解Embedding（词嵌入）
IT菜鸟
09-15 1万+
【Transformer系列】深入浅出理解Embedding（词嵌入）
一文读懂Embedding
qq_44866969的博客
08-28 5315
解读Embedding
【embedding 神经网络】神经网络算法 —— Embedding（嵌入）！！
python12222_的博客
07-02 1485
本文将从 Embedding 的本质、Embedding的原理、Embedding的应用三个方面，详细介绍Embedding（嵌入）。
一文读懂「Embedding」嵌入技术
女王の专属领地
01-31 2990
Embedding 是一种将高维数据（如文本或图像）转换为较低维度的向量表示的技术。这种表示捕捉了数据的关键特征，使得在处理、分析和机器学习任务中更加高效。通常用于将离散的、非连续的数据转换为连续的向量表示，以便于计算机进行处理。“Embedding”直译是嵌入式、嵌入层。通俗讲，我们常见的地图就是对于现实地理的Embedding，现实的地理地形的信息其实远远超过三维，但是地图通过颜色和等高线等来最大化表现现实的地理信息。
【深度学习】embedding的简单理解
wzk4869的博客
03-04 3517
【深度学习】embedding的简单理解
Embedding模块
最新发布
10-19
Embedding模块是深度学习中用于处理离散类别数据的一种技术[^1]，它将每个离散的标识符映射到一个密集的实数值向量。这些向量通常具有较低的维度，有助于减少参数数量并缓解过拟合问题。 在推荐系统中，例如Airbnb...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值