手写实现skip gram并实现霍夫曼树与负采样优化

原创 已于 2024-03-15 23:45:02 修改
· 151 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#霍夫曼树 #深度学习 #数据结构

于 2022-02-22 19:57:40 首次发布

目录

一、skip gram 基本实现

 二、霍夫曼树实现

  2.1、Huffman 树实现方法

  2.2、Huffman 优化 skip gram

三、负采样实现

一、skip gram 基本实现

# 没有对FC层进行优化的 skip gram
import torch
import torch.nn.functional as F
import numpy as np
np.random.seed(1)
import pandas as pd
import torch.optim as optim
from torch.autograd import Variable, profiler
from collections import Counter

corpus = ['he is a king',
          'she is a queen',
         'he is a man',
         'she is a woman',
         'warsaw is poland capital',
         'berlin is germany capital',
         'paris is france capital']

# 构建 word2id 词汇表 与 id2word
words = []
for sen in corpus:
    sen_words = sen.split()
    for sen_word in sen_words:
        if sen_word not in words:
            words.append(sen_word)
word2id = {word:idx for idx,word in enumerate(words)}
id2word = {idx:word for idx,word in enumerate(words)}
print(words)
print(word2id)
print(id2word)


embedding_size = 10
window_size = 2
# 构建训练数据对（中心词onehot、上下文词index）
def train_data_generator(corpus,word2id):
    for sen in corpus:
        sen_index = [word2id[w] for w in sen.split()]
        for cen_idx in range(len(sen_index)):
            for i in range(-window_size,window_size+1):     # i:  -2 -1 0 1 2
                context_idx = cen_idx + i
                # 将上下文单词索引越界或等于中心词的索引去除
                if context_idx < 0 or context_idx >= len(sen_index) or context_idx == cen_idx:
                    continue
                cen_id = sen_index[cen_idx]
                context_id = sen_index[context_idx]

                # 将中心词转化为onehot格式
                cen_onthot = np.zeros(len(word2id))
                cen_onthot[cen_id] = 1
                yield cen_onthot,cen_id,context_id


# 使用训练数据对进行训练
    # 创建 w1 与 w2 矩阵参数
w1 = torch.tensor(np.random.randn(len(word2id),embedding_size)
                        ,dtype=torch.float32,requires_grad=True)
w2 = torch.tensor(np.random.randn(embedding_size,len(word2id))
                        ,dtype=torch.float32,requires_grad=True)
print(w1.size())

def trainer():
    for epoch in range(600):
        avg_loss = 0
        samples = 0
        for cen_onehot,_,context_id in train_data_generator(corpus,word2id):
            cen_onehot = torch.from_numpy(np.array([cen_onehot])).float()
            context_id = torch.from_numpy(np.array([context_id])).long()
            samples += len(context_id)
            # 计算
            hidden_state = torch.matmul(cen_onehot,w1)
            output = torch.matmul(hidden_state,w2)

            # 计算 loss
            output = F.log_softmax(output,dim=1)
            loss = F.nll_loss(output,context_id)
            loss.backward()

            # 更新参数
            w1.data -= 0.01 * w1.grad.data
            w2.data -= 0.01 * w2.grad.data
            w1.grad.data.zero_()
            w2.grad.data.zero_()

            avg_loss += loss.item()

        if epoch % 50 == 0:
            print(avg_loss / samples)

if __name__ == "__main__":
    trainer()

    # 绘图
    from scikitplot.decomposition import plot_pca_2d_projection
    from sklearn.decomposition import PCA
    import matplotlib.pyplot as plt
    pca = PCA(n_components=2)
    pca.fit(w1.data.numpy())
    ax = plot_pca_2d_projection(pca, w1.data.numpy(), np.array(words), feature_labels=words, figsize=(12, 12),
                                text_fontsize=12)

    # 为绘图的数据点添加txt
    proj = pca.transform(w1.data.numpy())
    for i, txt in enumerate(words):
        ax.annotate(txt, (proj[i, 0], proj[i, 1]), size=16)
    plt.show()

 二、霍夫曼树实现

  2.1、Huffman 树实现方法

# 构建霍夫曼树
    # 构建霍夫曼树节点
class HuffmanNode():
    def __init__(self,value,possibility):
        # 节点的词频
        self.possibility = possibility
        # 节点的左右分支
        self.left = None
        self.right = None
        # 节点的值
        self.value = value
        # 节点的Huffman编码
        self.Huffman = ''

    # 构建霍夫曼树
class HuffmanTree():
    def __init__(self,word_dict,vector_size=10):
        self.vector_size = vector_size
        self.root = None
        word_dict_list = list(word_dict.values())
        node_list = [HuffmanNode(value=word_dict['word'],possibility=word_dict['possibility']) for word_dict in word_dict_list]
        self.build_tree(node_list=node_list)

    # 合并两个词频最小的节点
    def merger_node(self,node1,node2):
        # 计算合并后新节点的词频
        possibility = node1.possibility + node2.possibility
        merger_node = HuffmanNode(value=np.random.randn(self.vector_size),possibility=possibility)
        # 将词频较大的节点放在左边
        if node1.possibility >= node2.possibility:
            merger_node.left = node1
            merger_node.right = node2
        else:
            merger_node.left = node2
            merger_node.right = node1
        return merger_node

    # 构建huffman树
    def build_tree(self,node_list):
        while node_list.__len__() > 1:
            # 创建两个词频最小的节点的索引
            i0 = 0   # 词频最小的节点
            i1 = 1   # 词频第二小的节点
            if node_list[i1].possibility < node_list[i0].possibility:
                i0,i1 = i1,i0
            # 找出最小的两个节点的索引
            for idx in range(2,len(node_list)):
                if node_list[idx].possibility < node_list[i1].possibility:
                    i1 = idx
                    if node_list[i1].possibility < node_list[i0].possibility:
                        i0, i1 = i1, i0
            # 合并节点
            merger_node = self.merger_node(node_list[i0],node_list[i1])
            # 删除最小的两个节点，由于列表删除元素后会对该元素后面的元素的索引产生影响，因此我们优先从索引大的开始删起
            if i1 > i0:
                node_list.pop(i1)
                node_list.pop(i0)
            elif i0 > i1:
                node_list.pop(i0)
                node_list.pop(i1)
            else:
                raise RuntimeError('i1 不能与 i0 相等')
            # 将合并的新节点加入到原列表中
            node_list.insert(0,merger_node)

        # 构建根节点
        self.root = node_list[0]

    # 计算huffman编码，TODO 利用栈遍历整个二叉树，深度优先
    def generate_huffman_code(self,node,word_dict):
        # 构建一个栈，深度优先遍历这个树
        stack = [node]
        while stack.__len__() > 0:
            node = stack.pop()
            # 判断节点是否为叶子节点
            while node.left or node.right:
                code = node.Huffman
                node.left.Huffman = code + "1" # 左树词频较大的编码给1
                node.right.Huffman = code + "0"
                # 将右子树放入栈中
                stack.append(node.right)
                # 将node替换为左子树
                node = node.left

            word = node.value
            code = node.Huffman
            # 将霍夫曼编码计入词汇表的字典中
            word_dict[word]['Huffman'] = code
        return word_dict

  2.2、Huffman 优化 skip gram

import numpy as np
np.random.seed(1)
import pandas as pd
import torch.optim as optim
from torch.autograd import Variable, profiler
from collections import Counter

corpus = ['he is a king',
          'she is a queen',
         'he is a man',
         'she is a woman',
         'warsaw is poland capital',
         'berlin is germany capital',
         'paris is france capital']

# 构建 word2id 词汇表 与 id2word
words = []
for sen in corpus:
    sen_words = sen.split()
    for sen_word in sen_words:
        if sen_word not in words:
            words.append(sen_word)
word2id = {word:idx for idx,word in enumerate(words)}
id2word = {idx:word for idx,word in enumerate(words)}
print(words)
print(word2id)
print(id2word)

# 构建词频的字典
count_dic = {}
num_word = 0
for sen in corpus:
    for word in sen.split():
        if word not in count_dic:
            count_dic[word] = 1
        else:
            count_dic[word] += 1
        num_word += 1
print(count_dic)
count_dic = {word:count_dic[word] * 1.0/num_word for word in count_dic}
print(count_dic)

# 构建单词属性字典
word_dict = {}
for i,j in count_dic.items():
    dic = {}
    dic["word"] = i
    dic['possibility'] = j
    word_dict[i] = dic
print(word_dict)

# 构建霍夫曼树
    # 构建霍夫曼树节点
class HuffmanNode():
    def __init__(self,value,possibility):
        # 节点的词频
        self.possibility = possibility
        # 节点的左右分支
        self.left = None
        self.right = None
        # 节点的值
        self.value = value
        # 节点的Huffman编码
        self.Huffman = ''

    # 构建霍夫曼树
class HuffmanTree():
    def __init__(self,word_dict,vector_size=10):
        self.vector_size = vector_size
        self.root = None
        word_dict_list = list(word_dict.values())
        node_list = [HuffmanNode(value=word_dict['word'],possibility=word_dict['possibility']) for word_dict in word_dict_list]
        self.build_tree(node_list=node_list)

    # 合并两个词频最小的节点
    def merger_node(self,node1,node2):
        # 计算合并后新节点的词频
        possibility = node1.possibility + node2.possibility
        merger_node = HuffmanNode(value=np.random.randn(self.vector_size),possibility=possibility)
        # 将词频较大的节点放在左边
        if node1.possibility >= node2.possibility:
            merger_node.left = node1
            merger_node.right = node2
        else:
            merger_node.left = node2
            merger_node.right = node1
        return merger_node

    # 构建huffman树
    def build_tree(self,node_list):
        while node_list.__len__() > 1:
            # 创建两个词频最小的节点的索引
            i0 = 0   # 词频最小的节点
            i1 = 1   # 词频第二小的节点
            if node_list[i1].possibility < node_list[i0].possibility:
                i0,i1 = i1,i0
            # 找出最小的两个节点的索引
            for idx in range(2,len(node_list)):
                if node_list[idx].possibility < node_list[i1].possibility:
                    i1 = idx
                    if node_list[i1].possibility < node_list[i0].possibility:
                        i0, i1 = i1, i0
            # 合并节点
            merger_node = self.merger_node(node_list[i0],node_list[i1])
            # 删除最小的两个节点，由于列表删除元素后会对该元素后面的元素的索引产生影响，因此我们优先从索引大的开始删起
            if i1 > i0:
                node_list.pop(i1)
                node_list.pop(i0)
            elif i0 > i1:
                node_list.pop(i0)
                node_list.pop(i1)
            else:
                raise RuntimeError('i1 不能与 i0 相等')
            # 将合并的新节点加入到原列表中
            node_list.insert(0,merger_node)

        # 构建根节点
        self.root = node_list[0]

    # 计算huffman编码，TODO 利用栈遍历整个二叉树，深度优先
    def generate_huffman_code(self,node,word_dict):
        # 构建一个栈，深度优先遍历这个树
        stack = [node]
        while stack.__len__() > 0:
            node = stack.pop()
            # 判断节点是否为叶子节点
            while node.left or node.right:
                code = node.Huffman
                node.left.Huffman = code + "1" # 左树词频较大的编码给1
                node.right.Huffman = code + "0"
                # 将右子树放入栈中
                stack.append(node.right)
                # 将node替换为左子树
                node = node.left

            word = node.value
            code = node.Huffman
            # 将霍夫曼编码计入词汇表的字典中
            word_dict[word]['Huffman'] = code
        return word_dict

if __name__ == "__main__":
    vector_size = 10
    huffman = HuffmanTree(word_dict=word_dict,vector_size=vector_size)
    word_dict = huffman.generate_huffman_code(huffman.root,word_dict=word_dict)
    print(word_dict)
结果：
['he', 'is', 'a', 'king', 'she', 'queen', 'man', 'woman', 'warsaw', 'poland', 'capital', 'berlin', 'germany', 'paris', 'france']
{'he': 0, 'is': 1, 'a': 2, 'king': 3, 'she': 4, 'queen': 5, 'man': 6, 'woman': 7, 'warsaw': 8, 'poland': 9, 'capital': 10, 'berlin': 11, 'germany': 12, 'paris': 13, 'france': 14}
{0: 'he', 1: 'is', 2: 'a', 3: 'king', 4: 'she', 5: 'queen', 6: 'man', 7: 'woman', 8: 'warsaw', 9: 'poland', 10: 'capital', 11: 'berlin', 12: 'germany', 13: 'paris', 14: 'france'}
{'he': 2, 'is': 7, 'a': 4, 'king': 1, 'she': 2, 'queen': 1, 'man': 1, 'woman': 1, 'warsaw': 1, 'poland': 1, 'capital': 3, 'berlin': 1, 'germany': 1, 'paris': 1, 'france': 1}
{'he': 0.07142857142857142, 'is': 0.25, 'a': 0.14285714285714285, 'king': 0.03571428571428571, 'she': 0.07142857142857142, 'queen': 0.03571428571428571, 'man': 0.03571428571428571, 'woman': 0.03571428571428571, 'warsaw': 0.03571428571428571, 'poland': 0.03571428571428571, 'capital': 0.10714285714285714, 'berlin': 0.03571428571428571, 'germany': 0.03571428571428571, 'paris': 0.03571428571428571, 'france': 0.03571428571428571}
{'he': {'word': 'he', 'possibility': 0.07142857142857142}, 'is': {'word': 'is', 'possibility': 0.25}, 'a': {'word': 'a', 'possibility': 0.14285714285714285}, 'king': {'word': 'king', 'possibility': 0.03571428571428571}, 'she': {'word': 'she', 'possibility': 0.07142857142857142}, 'queen': {'word': 'queen', 'possibility': 0.03571428571428571}, 'man': {'word': 'man', 'possibility': 0.03571428571428571}, 'woman': {'word': 'woman', 'possibility': 0.03571428571428571}, 'warsaw': {'word': 'warsaw', 'possibility': 0.03571428571428571}, 'poland': {'word': 'poland', 'possibility': 0.03571428571428571}, 'capital': {'word': 'capital', 'possibility': 0.10714285714285714}, 'berlin': {'word': 'berlin', 'possibility': 0.03571428571428571}, 'germany': {'word': 'germany', 'possibility': 0.03571428571428571}, 'paris': {'word': 'paris', 'possibility': 0.03571428571428571}, 'france': {'word': 'france', 'possibility': 0.03571428571428571}}
{'he': {'word': 'he', 'possibility': 0.07142857142857142, 'Huffman': '1010'}, 'is': {'word': 'is', 'possibility': 0.25, 'Huffman': '01'}, 'a': {'word': 'a', 'possibility': 0.14285714285714285, 'Huffman': '110'}, 'king': {'word': 'king', 'possibility': 0.03571428571428571, 'Huffman': '10111'}, 'she': {'word': 'she', 'possibility': 0.07142857142857142, 'Huffman': '000'}, 'queen': {'word': 'queen', 'possibility': 0.03571428571428571, 'Huffman': '10110'}, 'man': {'word': 'man', 'possibility': 0.03571428571428571, 'Huffman': '10001'}, 'woman': {'word': 'woman', 'possibility': 0.03571428571428571, 'Huffman': '10000'}, 'warsaw': {'word': 'warsaw', 'possibility': 0.03571428571428571, 'Huffman': '10011'}, 'poland': {'word': 'poland', 'possibility': 0.03571428571428571, 'Huffman': '10010'}, 'capital': {'word': 'capital', 'possibility': 0.10714285714285714, 'Huffman': '001'}, 'berlin': {'word': 'berlin', 'possibility': 0.03571428571428571, 'Huffman': '11101'}, 'germany': {'word': 'germany', 'possibility': 0.03571428571428571, 'Huffman': '11100'}, 'paris': {'word': 'paris', 'possibility': 0.03571428571428571, 'Huffman': '11111'}, 'france': {'word': 'france', 'possibility': 0.03571428571428571, 'Huffman': '11110'}}

三、负采样实现

MATLAB算法实战应用案例精讲-【深度学习】多尺度特征提取（论文篇二）
qq_36130719的博客
04-17 717
对文本进行自动分类的过程。在该系统中，将待分类的文本输入到文本分类系统中，输出的是。涉及到的词嵌入和预训练语言模型、神经网络和深度学习、多尺度特征提取等技术。事实上，对于人脸对齐这种关联型任务，人脸各个部分，并不是在相同的。人工神经网络是模拟人类大脑的神经结构来进行设计的，用一种数学和计算模型。来模拟自然界生物的神经元活动，由大量相互连接的神经元来对信息进行计算和。传递，最终利用误差反向传播来对模型的参数进行调整，来拟合输入和输出的关。大多深度网络网络模型只使用最后一层的卷积特征，这样可能会造成信息的。
Word2vec：skip-gram模型+Negative Sampling(负采样)代码实现
ACM_hades的博客
01-31 4732
算法原理： 算法原理可以参考该链接 超参数 # Training Parameters learning_rate = 0.1 batch_size = 128 num_steps = 3000000 display_step = 10000 eval_step = 200000 # Evaluation Parameters valid_size = 20 valid_window =...
自然语言处理 - 文本数值化 - Word Embedding - 层次Softmax 与 负采样
GoWeiXH的小天地
05-16 1168
哈夫曼树 轮盘采样 Word Embedding 简化方法 层次 Softmax (Hierarchical Softmax ) 负采样 (Negative Sampling)
Skip-gram负采样原理及代码实现（pytorch）
weixin_45837958的博客
05-12 2578
绝大多数的词向量学习模型本质都是建立在词和其上下文之间的联系。比如我们常见的CBOW模型，是根据上下窗口中的词的合集作为输入去预测目标词，即，其中其中的k为超参数文本窗口大小。而skip-gram模型在此基础上做了进一步的简化，使用中的每一个词作为独立的上下文对目标词进行预测。因此skip-gram模型可以用于建立词与词之间的共现关系，即，其中。
负采样及其在skip-gram中的实现
weixin_44902962的博客
09-05 2058
本文参考了李沐老师在《动手学深度学习》中的代码，加入了自己的理解，并绘制了网络结构图，希望能让各位更理解负采样在skip-gram中的应用。
word2vec的原理和难点介绍(skip-gram,负采样、层次softmax)
traveler-leon的博客
11-18 8027
前言 本文仅作一个备忘录，不详细说明word2vec的两种词袋模型（skip-gram和CBOW),后面的记录默认是在skip-gram的基础下完成，即是利用中心词来预测上下文;同时也不涉及数学的推导计算，仅是做一些我认为比较重要的知识纪要。 word2vec是什么？ word2vec通常是一种进行文本的向量提取的技术，利用单词的共现（共同出现，后续会有详细记录）思想，通过对文本语料库进行训练，得到的每个单词的向量，最后可以通过向量来计算单词的相似性，或者说是共现概率。 是有监督还是无监督？ word2ve
（三）通俗易懂理解——Skip-gram的负采样
qq_36696494的博客
04-04 7053
针对前文的skip-gram以及CBOW的算法训练，当面对百万级的文本，就算是隐藏层是检索功能，其计算量也是相当大，而且还会造成冗余计算，这时候对高频词抽样以及负采样就应运而生了。 对高频词抽样 举例，原始文本为“The quick brown fox jumps over the laze dog”，如果我使用大小为2的窗口，那么我们可以得到图中展示的那些训练样本。 但是对于“the”...
skip-gram与负采样
ybdesire的专栏
08-19 2203
1. skip-gram模型 skip-gram是word2vec中的主要模型之一（另一个模型是CBOW）。简单来说，CBOW是给定上下文，来预测input-word；而skip-gram是给定input-word，来预测上下文。 下面我们来理解skip-gram模型。首先，给定句子如下 The man who passes the sentence should swing the sword.- 选择passes为中心词，window-size设置为3，则训练过程如下图 通过该图可以大致理解skip-
【word2vec】负采样（Negative Sampling）
最新发布
彬彬侠的博客
02-17 1398
负采样是Word2Vec中用来加速模型训练的一种技术。它通过从词汇表中随机选择一些负样本来减少计算量，从而使模型能够在大规模数据集上高效训练。负采样在 Skip-gram 和 CBOW 模型中得到了广泛应用，是生成高质量词向量的核心技术之一。虽然负采样在计算效率上有明显优势，但它也有一定的局限性，特别是在负样本选择和细节学习方面。
word2vec梳理--part2--负采样
人month神话
04-18 5539
在word2vec的第2部分（第1部分在这里（https://blog.youkuaiyun.com/fengrucheng/article/details/115705827）），将介绍对skip-gram模型的一系列优化，这些优化使得训练切实可行，因此非常重要。 首先再明确一下我们的任务本质：skip模型--输入中间词，输出周围词（这与CBOW模型不同--输入周围词，输出中间词） 当你看一些关于Word2Vec的skip-gram模型的教程时，你可能已经注意到了一些东西——这是一个巨大的神经网络！ 在之.
pytorch-sgns:PyTorch中的Skipgram负采样
05-04
PyTorch SGNS Python中Word2Vec的SkipGramNegativeSampling 。 在实现了另一个但非常普遍的。 它可以与任何嵌入方案一起使用！ 我敢打赌。 vocab_size = 20000 word2vec = Word2Vec ( vocab_size = vocab_size , embedding_size = 300 ) sgns = SGNS ( embedding = word2vec , vocab_size = vocab_size , n_negs = 20 ) optim = Adam ( sgns . parameters ()) for batch , ( iword , owords ) in enumerate ( dataloader ): loss = sgns ( iword , owords )
【机器学习】【Word Embedding，Word2Vec之Skip-Gram模型与负采样】
mystery_guest的博客
08-22 1602
一个单词或者一个字，要被计算机理解，那就要使其变成一个对应的值，这个值可以是vector。 要在程序中运用，一个想法就是构造词汇表，然后对照词汇表，对某个单词或字构造出一个向量。例如，假设有一张10000维度的词汇表，第1个单词是a，第2个是...直到第10000个单词是zelu，那么单词a对应的vector是(1,0,0,...,0)^T，只有第一个位置是1，其余位置都是0的1000维度的向量...
Skip-Gram模型和负采样
Python技术博文
11-15 1348
Skip-Gram模型根据中心词，预测或生成它的上下文单词。比如，根据jumped，预测或生成{“the”,“cat”,“over”,“the”,“puddle”}。显然，交换CBOW...
词向量模型skip-gram以及负采样技术图解
qq_34467412的博客
07-14 2845
一、前言 请勿全文复制转载！尊重劳动成果！ 在使用词向量之前，我们往往用one-hot向量来表示一个字词，这样有两个缺点： ① 维度过大。使用one-hot向量来表示字词，那么一个字词就需要一个词表大小的向量，而NLP任务中的词表往往是上万甚至上百万的，这会极大地增加神经网络中的参数数量。 ② 距离一致。使用one-hot...
个人总结：自然语言处理 word2vec(skip-gram/CBOW以及优化算法Hierarchical Softmax和Negative Sampling)
yyhhlancelot的博客
08-22 2621
前言 word2vec，顾名思义，将一个词转化为向量，也经常会看到一个非常相关的词“词嵌入”，也就是word embedding。词嵌入是一类将词从高维空间映射到低维空间的过程的统称，核心思想是将每个词都映射为低维空间(通常K=50-300维)上的一个稠密向量。K维空间的每一维可以看做一个隐含的主题，只不过不像主题模型中的主题那么直观。 假设每篇文章有N个词，每个词映射为K维的向量，那就可以用...
skip-gram-负采样中的神经网络操作过程详解
小姑仔的博客
12-08 698
如果batch_size = 128,正采样的单词左右各采样相应的3个单词,共采样6个单词 负采样共采样对应的60个相应的单词，则输入的矩阵中input_embedding = [128] pos_embedding = [128,6],neg_embedding = [128,60](注意这里面的batch=128的 情况下，每一次输入单词的维度应该一致) 然后使用扩充维度的操作使得input_embedding = [128,100],pos_embedding = [128,6,100],neg_em
自己动手写word2vec (四):CBOW和skip-gram模型
热门推荐
Multiangle's Notepad
07-18 8万+
CBOW和skip-gram应该可以说算是word2vec的核心概念之一了。这一节我们就来仔细的阐述这两个模型。其实这两个模型有很多的相通之处，所以这里就以阐述CBOW模型为主，然后再阐述skip-gram与CBOW的不同之处。这一部分的代码放在pyword2vec.py文件中1.CBOW模型之前已经解释过，无论是CBOW模型还是skip-gram模型，都是以Huffman树作为基础的。而Huffm
NLP之---word2vec算法skip-gram原理详解
Ricky
05-19 5万+
1.词嵌入（word2vec） 自然语言是一套用来表达含义的复杂系统。在这套系统中，词是表义的基本单元。顾名思义，词向量是用来表示词的向量，也可被认为是词的特征向量或表征。把词映射为实数域向量的技术也叫词嵌入（word embedding）。近年来，词嵌入已逐渐成为自然语言处理的基础知识。 2.为何不采用one-hot向量 【如何使用one-hot】 假设词典中不同词的数量（词典大小）为NNN...
自然语言处理：CBOW（哈夫曼树）与Skip-Gram模型
qq_41627642的博客
02-05 2367
自然语言处理：CBOW（哈夫曼树）与Skip-Gram模型 gensim库中的word2vev中模型主要使用了CBOW（哈夫曼树）与Skip-Gram模型。CBOW表示基于上下文来预测目标词，即输入是2c个上下文词（c表示窗口大小），输出是目标词的概率；Skip-Gram则是恰恰相反，输入是当前的目标词，输出则是上下文词的概率。 在确定了输入输出之后，其实训练的方式也就很明显了，（例如CBOW）输...
PyTorch实现SkipGram负采样：Word2Vec模型详解
PyTorch SGNS是用于实现Skip-Gram模型配合负采样技术的一个库，它在Python环境中利用PyTorch框架进行深度学习模型的构建。Skip-Gram模型是一种常用于自然语言处理（NLP）中的词嵌入方法，其目的是将词语转换为稠密的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值