Pytorch 中的Embedding理解

已于 2023-05-12 13:50:16 修改
阅读量809 收藏 1
点赞数
分类专栏： DeepLearning 文章标签： pytorch 深度学习 人工智能
于 2023-05-12 13:42:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jodieone/article/details/130639651
版权

文章目录

1 Word Embed

理解Embeding首先需要理解Word Embed，那什么是Word Embed呢？

即将word转化为tensor：

This is an apple!  ->  [[0.1, 0.2], [0.2, 0.3], [0.1, 0.4], [0.2, 0.2]]

词嵌入的过程，就相当于是我们在给计算机制造出一本字典的过程， key为index或者词，value为向量

通过这个字典来间接地识别文字，那这个如何理解，首先就要知道one-hot向量

1.1 One-hot编码

rap   -> [0, 0, 0, 0, 1, 0]
apple -> [0, 0, 0, 1, 0, 0]
is    -> [0, 0, 1, 0, 0, 0]
red   -> [0, 1, 0, 0, 0, 0]

每一个单词都被表示为one-hot向量，建立了一个字典，通过[0, 0, 0, 0, 1]能查询到单词this， 但是one-hot 编码有两个问题：

  1. 难以对大的文本数据建模，想象一下，对于有上万单词的文本建立one-hot的维度就有上万维度
  2. 难以表示文本之间的语义关系

对于第一个问题，这个比较好理解

对于第二个问题：

Rap    -> [0, 0, 0, 0, 1, 0]
banana -> [1, 0, 0, 0, 0, 0]
is     -> [0, 0, 1, 0, 0, 0]
yellow -> [0, 0, 0, 0, 0, 1]

apple和banana是有语义关系的，它们都是水果，都是成熟的，但是使用one-hot向量难以表示其内在的关系，使用词嵌入来解决这个问题

1.2 Word Embed理解

可以知道apple和banana都是水果，它们都是熟的，一个生长在热带一个生长在温带，根据这三个关系，我们建立词嵌入

		rap   friut tropical
apple   [1.0, 1.0,  0.2]
banana  [1.0, 1.0,  0.8]

因此我们根据这样的规则就可以建立一个词嵌入，并能表示他们的关系， 因此提出词嵌入：Word Embed，它是将词按照一定的规则映射为一个向量

同时可知他们之间的关系：

apple_embed = banana_embed[0] * 1 + banana_embed[1] * 1 + banana_embed[2] * 0.25

1.3 总结

从one-hot 到 query-embed

  • 单词的向量表示从稀疏态变成了密集态
  • 相互独立向量建立了内在联系的关系

2 Pytorch中的embeding

Doc: https://pytorch.org/docs/stable/generated/torch.nn.Embedding.html?highlight=embeding

A simple lookup table that stores embeddings of a fixed dictionary and size.

This module is often used to store word embeddings and retrieve them using indices. The input to the module is a list of indices, and the output is the corresponding word embeddings.

建立一个字典：将一个scale（index） 以一定的规则映射为一个tensor，使用index进行索引，并且这个规则是可学习的

参数：

  • init: num_embeddings：下标的长度 , embedding_dim ：向量的维度
  • Input: 输入下标大小，输入范围为：>=0 ， < num_embedding，按照词的index进行编码
  • output: 输出编码后的向量，前面的维度与input的前面的维度相同，维度为embedding_dim
  • 初始化的规则：均值为0，方差为1的正态分布，并且是可学习的
weight (Tensor) – the learnable weights of the module of shape (num_embeddings, embedding_dim) initialized from N(0,1)

3 Example

3.1 Ex1 一维编码

import torch
import torch.nn as nn

# 定义词嵌入
num_query = 10
hidden_dim = 3
embed = nn.Embedding(num_query, hidden_dim)

# 定义输入
input_tensor = torch.tensor([1, 2, 3, 1])
b = embed(input_tensor)


# 输出系数
embed.weight, b

>>>

(Parameter containing:
 tensor([[ 0.0739,  0.1857,  0.0616],
         [ 0.5078,  0.9804,  1.2938],
         [-1.6650,  0.1880,  0.3921],
         [ 0.7753,  1.5514,  0.2877],
         [ 0.1817, -0.7859, -0.7943],
         [-1.5885,  0.3873,  0.2072],
         [-0.4109, -2.1112,  1.7696],
         [ 0.6706, -0.1292, -2.3005],
         [ 1.3861, -0.5765,  1.3436],
         [-0.8233, -0.1140,  0.6213]], requires_grad=True),
 tensor([[ 0.5078,  0.9804,  1.2938],
         [-1.6650,  0.1880,  0.3921],
         [ 0.7753,  1.5514,  0.2877],
         [ 0.5078,  0.9804,  1.2938]], grad_fn=<EmbeddingBackward0>))

3.2 Ex2 多维度编码

import torch
import torch.nn as nn

# 定义词嵌入
num_query = 10
hidden_dim = 3
embed = nn.Embedding(num_query, hidden_dim)

# 定义输入
input_tensor = torch.tensor([[1, 2], [3, 1]])
b = embed(input_tensor)


# 输出系数
embed.weight, b

>>>
(Parameter containing:
 tensor([[-0.1994, -0.7068,  0.1735],
         [-0.6465, -0.1401, -0.1157],
         [-0.3184,  0.5307, -0.2699],
         [-1.2810,  2.5731, -2.0119],
         [-0.5721, -0.9300, -0.9147],
         [ 1.0049,  0.5798,  0.0149],
         [ 0.5879, -1.5378,  1.4790],
         [ 0.8585,  1.5588, -1.8052],
         [ 0.6283, -1.2635,  0.8070],
         [-1.5081, -0.2307, -1.0041]], requires_grad=True),
 tensor([[[-0.6465, -0.1401, -0.1157],
          [-0.3184,  0.5307, -0.2699]],
 
         [[-1.2810,  2.5731, -2.0119],
          [-0.6465, -0.1401, -0.1157]]], grad_fn=<EmbeddingBackward0>))

3.3 超过下标后报错

import torch
import torch.nn as nn

# 定义词嵌入
num_query = 10
hidden_dim = 3
embed = nn.Embedding(num_query, hidden_dim)

# 定义输入
input_tensor = torch.tensor([0, 10])
b = embed(input_tensor)


# 输出系数
embed.weight, b

>>>

IndexError Traceback (most recent call last) /tmp/ipykernel_2335/1048340143.py in <module>
      9 # 定义输入
     10 input_tensor = torch.tensor([0, 10])
---> 11 b = embed(input_tensor)
********
IndexError: index out of range in self

通过上面的实验可以看出每次embed.weight都是随机初始化的，下标查询的维度不可超出num_embeddings

参考

pytorch embedding层详解（从原理到实战）https://blog.csdn.net/weixin_43914889/article/details/104699657

深入理解 Embedding层的本质 https://blog.csdn.net/weixin_42078618/article/details/84553940

jodieone
关注
专栏目录
深入理解PyTorch中的nn.Embedding
⚡
06-27 1万+
深入理解nn.Embedding模块
pytorch nn.Embedding的用法和理解
热门推荐
qq_39540454的博客
03-25 6万+
首先来看official docs对nn.Embedding的定义： 是一个lookup table，存储了固定大小的dictionary（的word embeddings）。输入是indices，来获取指定indices的word embedding向量。 官方文档的示例： >>> # an Embedding module containing 10 tensors of size 3 >>> embedding = nn.Embedding(10, 3) &gt
pytorch embedding层详解（从原理到实战）
skywf的博客
03-06 5万+
做nlp很多时候要用到嵌入层，pytorch中自带了这个层 什么是embedding层 这是一个写的比较好的 我用最通俗的语言给你讲 在nlp里，embedding层就是把单词表[‘你’，‘好’，‘吗’] 编码成 ‘你’ --------------[0.2,0.1] ‘好’ --------------[0.3,0.2] ‘吗’ --------------[0.6,0.5] 的向量的办...
pytorch中的Embedding
fly_Xiaoma的博客
07-07 2万+
词向量（Word Vector），又称为词嵌入（Word Embedding），它是把一个维数为所有词的数量的高维空间嵌入到一个维数低得多的连续向量空间（通常是128维或256维)中，每个词或词组被映射为实数域上的向量。 pytorch中，针对词向量有一个专门的层nn.Embedding，用来实现词与词向量的映射。nn.Embedding具有一个权重，形状是(num_embeddings,emb...
pytorch——embedding层
七月听雪的博客
08-29 8131
深度学习框架主要是整明白，每一层的输入输出。 是什么： embed = torch.nn.Embedding(n_vocabulary,embedding_size) embedding层（嵌入层）其实就是一个（n_vocabulary*embedding_size ）矩阵，n_vocabulary代表你有多少个词，embedding_size代表每一个词的词向量的维度。所以这个矩阵就是保...
Pytorch中的Embedding方法
F845992311的博客
03-14 9032
在深度学习中，构建用户或物品的embedding是很常见的操作，那么在pytorch中是如何去做的呢？接下来我们就介绍非常重要的一个方法即：torch.nn.Embedding()。老规矩先来看一个小例子： # 导包，需要torch和torch.nn import torch from torch import nn # 构建一个embedding module，其包含5个size为3的tensor # 这里的embedding相当于是一个Embedding层，写于forward()方法中，还...
基于Pytorch的Embedding词向量编码功能实现
最新发布
05-08
首先，我们要理解PyTorch中的`torch.nn.Embedding`模块。这是一个用于存储词嵌入的查找表，其中每个单词都与一个固定大小的向量相对应。当我们输入一个单词的索引时，`Embedding`层会返回相应的向量表示。这个索引...
在pytorch中embedding层的作用
05-14
在 PyTorch 中，embedding 层的作用是将输入的离散化的数据（如单词、字符等）映射到一个低维的连续向量空间中。这个映射的过程可以理解为是一个查表的过程，每个离散化的数据都对应着一个唯一的向量。 这个过程...
pytorch中nn.Embedding理解
养猪的纺织工
11-28 603
给输入的词创建词向量 import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from torch.autograd import Variable word={'hello':0,'world':1} print(word) embeds = nn.Embedding(2, 6) hello_idx = torch.LongTensor([word['hello']]) hello_idx
PyTorch中的Embedding
Mark_Australia的博客
03-30 674
Embedding
pytorch embedding 理解
qq_39951635的博客
03-13 628
可见知乎 之前由于懒且不重视没思考embedding，故近期实战对其有些“误解”。害，可见这都是之前欠下的债啊，得补上！小白记录贴，仅供参考~ 从pytorch源码里简单找了找,并没有找到对embedding有直观解释的代码,故转向tensorflow。 不管什么框架,原理得是一样的吧~对embedding追根溯源，发现主要包括两部分： 对input[batch_size, seq_len]进行one-hot编码[batch_size, vocab_size]; 将one-hot编码后的矩阵和we
PyTorch学习笔记之初识word_embedding
Javier9201的博客
07-13 206
1 import torch 2 import torch.nn as nn 3 from torch.autograd import Variable 4 5 word2id = {'hello': 0, 'world': 1} 6 # you have 2 words, and then need 5 dim each word 7 embeds = ...
深度学习embedding方法，降维，以及pytorch中使用embedding
weixin_41106546的博客
04-24 4116
形式上讲，Embedding就是用。
PyTorch入门（八）Embedding层
山阴少年
03-19 1304
本文将会介绍PyTorch中的Embedding层
pytorch Embedding模块，自动为文本加载预训练的embedding
呆萌的代Ma
08-20 2170
pytorch 提供了一个简便方法torch.nn.Embedding.from_pretrained，可以将文本与预训练的embedding对应起来： 词 embedding word1 0,2,3,4 word2 1,2,3,4 word3 2,2,3,4 … … 使用方法就是： 首先有一个预训练的embedding列表： torch.Tensor([ [0, 2, 3, 4], [1, 2, 3, 4], [2, 2, 3, 4], [3, 2, 3, 4],
Pytorch 中 Embedding 类详解
Flag_ing的博客
04-02 6121
在 NLP 领域，可以使用 Pytorch 的 torch.nn.Embeding() 类对数据进行词嵌入预处理。关于词嵌入的解释这里就不做解释咯，不明白的阔以先出门左拐找百度。 重点说下这个 Embeding 类怎么用的。其定义如下： (class) Embedding(num_embeddings: int, embedding_dim: int, padding_idx: int | None = None, ...) 我这里只显示了三个参数：num_embeddings、embedding
pytorch 的embeding
geter_CS的博客
10-25 917
pytorch提供word embeding的功能来构建词向量，非稀疏向量。我们来看看他的定义方式： import torch.nn as NN import torch from torch.autograd import Variable embeding=NN.Embedding(6,5) print(embeding.weight) 输出： Parameter containing...
pytorch Embedding的实战和用法解析
梁先森的博客
07-18 9350
本篇博客着重于进行代码实战讲解，目的是弄清楚它的实际运行情况和常规参数表达含义。至于一些理论的东西，我认为其他博主解释的已经相当好了，在下面的文章中我也会将其引用出来。 为什么使用嵌入层Embedding？ 来源：https://www.jiqizhixin.com/articles/2019-03-27-7 1、使用One-hot 方法编码的向量会很高维也很稀疏。假设我们在做自然语言处理（NLP）中遇到了一个包含2000个词的字典，当使用One-hot编码时，每一个词会被一个包含2000个整数的向.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值