Transformer

人生彷徨何处寻觅

于 2023-05-06 00:02:06 发布

阅读量76

点赞数

分类专栏： ChatGPT入门 AIGC 文章标签： transformer 深度学习机器学习

本文链接：https://blog.csdn.net/weixin_37410657/article/details/130517703

版权

AIGC 同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

ChatGPT入门

16 篇文章 0 订阅

订阅专栏

Transformer

1. 简介

在自然语言处理（NLP）领域，深度学习模型的发展一直在不断推进。从最初的神经网络语言模型（NNLM）到现在的BERT，这些模型在处理文本数据的能力上有了显著的提升。本文将详细介绍这些模型的发展历程，以及它们的基本原理和应用场景。我们将逐步理解Word2Vec、Seq2Seq、带注意力机制的Seq2Seq、Transformer、Elmo、GPT和BERT，并通过Python代码和LaTeX公式进行详细解析。

2. NNLM（神经网络语言模型）

NNLM是一种基于神经网络的语言模型，它的目标是预测给定单词序列的下一个单词。NNLM通过学习词向量表示来捕捉词语之间的语义关系，并使用神经网络进行预测。

2.1 原理分析

NNLM的核心是一个前馈神经网络，输入层为词嵌入层，输出层为softmax层。给定一个单词序列，模型首先将每个单词映射到词嵌入空间，然后通过神经网络计算下一个单词的概率分布。

2.2 Python代码示例

# NNLM模型实现
import torch
import torch.nn as nn

class NNLM(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim):
        super(NNLM, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.linear1 = nn.Linear(embed_dim, hidden_dim)
        self.linear2 = nn.Linear(hidden_dim, vocab_size)
        self.softmax = nn.Softmax(dim=1)
        
    def forward(self, x):
        x = self.embedding(x)
        x = torch.sum(x, dim=1)
        x = self.linear1(x)
        x = torch.relu(x)
        x = self.linear2(x)
        x = self.softmax(x)
        return x

# 实例化模型
vocab_size = 10000
embed_dim = 100
hidden_dim = 50
model = NNLM(vocab_size, embed_dim, hidden_dim)

3. Word2Vec

Word2Vec是一种用于生成词向量的模型，它能够捕捉词语之间的

语义和语法关系。Word2Vec有两种主要变体：CBOW（Continuous Bag of Words）和Skip-gram。

3.1 原理分析

CBOW：CBOW模型通过上下文单词预测目标单词。给定一个窗口大小，模型使用窗口内的单词作为输入，预测窗口中心的单词。
Skip-gram：Skip-gram模型与CBOW相反，它通过目标单词预测上下文单词。给定一个窗口大小，模型使用窗口中心的单词作为输入，预测窗口内的其他单词。

两种模型都通过最大化似然函数进行训练，以学习词向量表示。

3.2 Python代码示例

# Word2Vec Skip-gram模型实现
import torch
import torch.nn as nn

class SkipGram(nn.Module):
    def __init__(self, vocab_size, embed_dim):
        super(SkipGram, self).__init__()
        self.in_embed = nn.Embedding(vocab_size, embed_dim)
        self.out_embed = nn.Embedding(vocab_size, embed_dim)
        
    def forward(self, target, context):
        in_embeds = self.in_embed(target)
        out_embeds = self.out_embed(context)
        scores = torch.matmul(in_embeds, out_embeds.t())
        return scores

# 实例化模型
vocab_size = 10000
embed_dim = 100
model = SkipGram(vocab_size, embed_dim)

4. Seq2Seq（序列到序列模型）

Seq2Seq模型是一种端到端的序列生成模型，常用于机器翻译、语音识别等任务。Seq2Seq模型由编码器和解码器两部分组成。

4.1 原理分析

编码器：编码器负责将输入序列编码成一个固定长度的向量表示。
解码器：解码器根据编码器的输出生成目标序列。

Seq2Seq模型通常使用循环神经网络（RNN）作为编码器和解码器的基本结构。

4.2 Python代码示例

# Seq2Seq模型实现
import torch
import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(Encoder, self).__init__()
        self.rnn = nn.GRU(input_dim, hidden_dim, batch_first=True)
        
    def forward(self, x):
        _, hidden = self.rnn(x)
        return hidden

class Decoder(nn.Module):
    def __init__(self, output_dim, hidden_dim):
        super(Decoder, self).__init__()
        self.rnn = nn.GRU(output_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
        
    def forward(self, x, hidden):
        output, hidden = self.rnn(x, hidden)
        output = self.fc(output)
        return output, hidden

class Seq2Seq(nn.Module):
    def __init__(self, input_dim, output_dim, hidden_dim):
        super(Seq2Seq, self).__init__()
        self

.encoder = Encoder(input_dim, hidden_dim)
        self.decoder = Decoder(output_dim, hidden_dim)
        
    def forward(self, src, trg):
        hidden = self.encoder(src)
        output, hidden = self.decoder(trg, hidden)
        return output

# 实例化模型
input_dim = 100
output_dim = 100
hidden_dim = 50
model = Seq2Seq(input_dim, output_dim, hidden_dim)

5. Seq2Seq with Attention（带注意力机制的序列到序列模型）

Seq2Seq模型的一个缺点是编码器将整个输入序列压缩成一个固定长度的向量，这可能导致信息丢失。为了解决这个问题，引入了注意力机制。

5.1 原理分析

注意力机制允许解码器在生成每个输出单词时关注输入序列的不同部分。具体来说，注意力机制为输入序列中的每个单词分配一个权重，这些权重决定了解码器在生成当前单词时应该关注输入序列的哪些部分。

5.2 Python代码示例

# Seq2Seq模型带注意力机制实现
import torch
import torch.nn as nn
import torch.nn.functional as F

class Attention(nn.Module):
    def __init__(self, hidden_dim):
        super(Attention, self).__init__()
        self.attn = nn.Linear(hidden_dim * 2, hidden_dim)
        self.v = nn.Linear(hidden_dim, 1, bias=False)
        
    def forward(self, hidden, encoder_outputs):
        batch_size, seq_len, _ = encoder_outputs.size()
        hidden = hidden.repeat(1, seq_len, 1)
        energy = torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim=2)))
        attention = self.v(energy).squeeze(2)
        return F.softmax(attention, dim=1)

class DecoderWithAttention(nn.Module):
    def __init__(self, output_dim, hidden_dim):
        super(DecoderWithAttention, self).__init__()
        self.rnn = nn.GRU(output_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim * 2, output_dim)
        self.attention = Attention(hidden_dim)
        
    def forward(self, x, hidden, encoder_outputs):
        attention_weights = self.attention(hidden, encoder_outputs)
        attention_weights = attention_weights.unsqueeze(1)
        weighted = torch.bmm(attention_weights, encoder_outputs)
        rnn_input = torch.cat((x, weighted), dim=2)
        output, hidden = self.rnn(rnn_input, hidden)
        output = self.fc(torch.cat((output, weighted), dim=2).squeeze(1))
        return output, hidden

class Seq2SeqWithAttention(nn.Module):
    def __init__(self, input_dim, output_dim, hidden_dim):
        super(Seq2SeqWithAttention, self).__init__()
        self.encoder = Encoder(input_dim, hidden_dim)
        self.decoder = DecoderWithAttention(output_dim, hidden_dim)
        
    def forward(self, src, trg):
        encoder_outputs, hidden = self.encoder(src)
        output, hidden = self.decoder(trg, hidden, encoder_outputs)
        return output

# 实例化模型
input_dim = 100
output_dim = 100
hidden_dim = 50
model = Seq2SeqWith

Attention(input_dim, output_dim, hidden_dim)

6. Transformer

Transformer模型是一种基于自注意力机制的序列到序列模型，它摒弃了传统的循环神经网络结构，完全依赖自注意力机制进行序列建模。

6.1 原理分析

Transformer模型由编码器和解码器组成，每个编码器和解码器都包含多个自注意力层和前馈神经网络层。自注意力机制允许模型在处理每个单词时关注序列中的其他单词，从而捕捉长距离依赖关系。

6.2 Python代码示例

# 简化版Transformer模型实现
import torch
import torch.nn as nn

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        self.head_dim = d_model // num_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.fc = nn.Linear(d_model, d_model)
        
    def forward(self, query, key, value):
        # 分割多头
        Q = self.W_q(query).view(-1, self.num_heads, self.head_dim)
        K = self.W_k(key).view(-1, self.num_heads, self.head_dim)
        V = self.W_v(value).view(-1, self.num_heads, self.head_dim)
        # 自注意力计算
        attention = torch.matmul(Q, K.transpose(-2, -1)) / self.head_dim**0.5
        attention = torch.softmax(attention, dim=-1)
        attention_output = torch.matmul(attention, V)
        # 拼接多头
        attention_output = attention_output.view(-1, self.d_model)
        output = self.fc(attention_output)
        return output

class Transformer(nn.Module):
    def __init__(self, d_model, num_heads):
        super(Transformer, self).__init__()
        self.multi_head_attention = MultiHeadAttention(d_model, num_heads)
        self.fc = nn.Linear(d_model, d_model)
        
    def forward(self, x):
        attention_output = self.multi_head_attention(x, x, x)
        output = self.fc(attention_output)
        return output

# 实例化模型
d_model = 512
num_heads = 8
model = Transformer(d_model, num_heads)

7. Elmo

Elmo（Embeddings from Language Models）是一种上下文相关的词向量模型，它能够为每个单词生成动态词向量，这些词向量能够根据上下文进行调整。

7.1 原理分析

Elmo模型使用双向长短时记忆网络（BiLSTM）作为语言模型，通过对每个单词的前向和后向隐藏状态进行加权求和，生成上下文相关的词向量。

7.2 Python代码示例


python
# 简化版Elmo模型实现
import torch
import torch.nn as nn

class Elmo(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim):
        super(Elmo, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm_fw = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        self.lstm_bw = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        
    def forward(self, x):
        x_embed = self.embedding(x)
        # 前向LSTM
        output_fw, _ = self.lstm_fw(x_embed)
        # 后向LSTM
        output_bw, _ = self.lstm_bw(torch.flip(x_embed, [1]))
        # 拼接前向和后向输出
        output = torch.cat((output_fw, torch.flip(output_bw, [1])), dim=2)
        return output

# 实例化模型
vocab_size = 10000
embed_dim = 100
hidden_dim = 50
model = Elmo(vocab_size, embed_dim, hidden_dim)

8. GPT（生成式预训练Transformer）

GPT（Generative Pre-trained Transformer）是一种基于Transformer的自回归语言模型，它通过预训练和微调两个阶段进行训练。

8.1 原理分析

GPT模型的预训练阶段使用大量无标签文本数据进行训练，目标是预测给定上下文的下一个单词。微调阶段使用有标签数据对模型进行微调，以适应特定的NLP任务。

8.2 Python代码示例

# GPT模型实现略，可以使用Hugging Face的Transformers库直接加载预训练的GPT模型
from transformers import GPT2Tokenizer, GPT2LMHeadModel

# 加载预训练的GPT-2模型和分词器
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
model = GPT2LMHeadModel.from_pretrained('gpt2')

# 使用GPT-2生成文本
input_text = "Once upon a time,"
input_ids = tokenizer.encode(input_text, return_tensors='pt')
output = model.generate(input_ids, max_length=50, num_return_sequences=1)
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
print(generated_text)

9. BERT（双向编码器表示Transformer）

BERT（Bidirectional Encoder Representations from Transformers）是一种基于Transformer的预训练语言模型，它能够捕捉文本中的双向上下文信息。

9.1 原理分析

BERT模型的预训练阶段包括两个任务：掩码语言模型（Masked Language Model, MLM）和下一句预测（Next Sentence Prediction, NSP）。通过这两个任务，BERT能够学习到双向上下文信息。

9.2 Python代码示例

# 使用Hugging Face的Transformers库加载预训练的BERT模型和分词器
from transformers import BertTokenizer, BertModel

# 加载预训练的BERT模型和分词器
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

# 使用BERT模型提取文本特征
input_text = "The quick brown fox jumps over the lazy dog."
input_ids = tokenizer.encode(input_text, return_tensors='pt')
with torch.no_grad():
    outputs = model(input_ids)
    last_hidden_states = outputs[0]  # 获取最后一层的隐藏状态

# 输出BERT模型的文本特征表示
print(last_hidden_states)

10. 总结

本文详细介绍了自然语言处理中的一系列重要模型，包括NNLM、Word2Vec、Seq2Seq、带注意力机制的Seq2Seq、Transformer、Elmo、GPT和BERT。这些模型在处理文本数据的能力上有了显著的提升，为自然语言处理任务提供了强大的工具。希望通过本文的介绍，读者能够对这些模型有更深入的理解，并能够灵活运用到实际的自然语言处理任务中。

参考文献

Mikolov, T., Chen, K., Corrado, G., & Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781.
Sutskever, I., Vinyals, O., & Le, Q. V. (2014). Sequence to sequence learning with neural networks. Advances in neural information processing systems, 27, 3104-3112.
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., … & Polosukhin, I. (2017). Attention is all you need. Advances in neural information processing systems, 30, 5998-6008.
Peters, M. E., Neumann, M., Iyyer, M., Gardner, M., Clark, C., Lee, K., & Zettlemoyer, L. (2018). Deep contextualized word representations. arXiv preprint arXiv:1802.05365.
Radford, A., Narasimhan, K., Salimans, T., & Sutskever, I. (2018). Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws.com/openai-assets/research-covers/languageunsupervised/language understanding paper.pdf.
Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers) (pp. 4171-4186).

人生彷徨何处寻觅

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Transformer

在自然语言处理（NLP）领域，深度学习模型的发展一直在不断推进。从最初的神经网络语言模型（NNLM）到现在的BERT，这些模型在处理文本数据的能力上有了显著的提升。本文将详细介绍这些模型的发展历程，以及它们的基本原理和应用场景。我们将逐步理解Word2Vec、Seq2Seq、带注意力机制的Seq2Seq、Transformer、Elmo、GPT和BERT，并通过Python代码和LaTeX公式进行详细解析。
复制链接

扫一扫