PyTorch 深度学习实践-循环神经网络基础篇

视频指路
参考博客笔记
参考笔记二

文章目录

  • 上课笔记
    • 基于RNNCell实现
      • 总代码
    • 基于RNN实现
      • 总代码
    • 含嵌入层的RNN网络
      • 嵌入层的作用
      • 含嵌入层的RNN网络架构
      • 总代码
    • 其他RNN扩展
      • 基本注意力机制
      • 自注意力机制(Self-Attention)
      • 自注意力计算
      • 多头注意力机制(Multi-Head Attention)
      • Transformer模型
      • 简单的Transformer编码器


上课笔记

例子:每天若干特征,若干天作为输出

使用cnn的时候要明确全连接层占的权重比例特别大,是训练的瓶颈,通过权重共享的概念来减少需要训练的权重的数量

RNN cell本质就是一个线性层,但是这个线性层是共享的,如下图,每次把hi和xi+1计算得到的hi+1传送到下一层进行计算,同时xi+1还需要通过某种运算融合xi的信息(比如求和、求乘积等)h0是先验知识,比如对于图像生成文本,可以先通过cnn+fc生成h0,也可以把h0设成和h1等统一维度的向量,值都设成0。所有的rnnc都处于同一个线性层

在这里插入图片描述

RNN网络最大的特点就是可以处理序列特征,就是我们的一组动态特征。比如,我们可以通过将前三天每天的特征(是否下雨,是否有太阳等)输入到网络,从而来预测第四天的天气。

知识点:RNN处理数据维度,两种构建RNN的方法

问题描述:对于序列数据采用循环神经网络

11.1 RNNCell
主要内容:随机生成seq_size个句子,通过h0为全零的RNN网络,探究输入输出以及隐层的维度

代码实现:利用RNNCell处理单个运算,RNNCell只是RNN的一个单元,用于处理一个时间步的输入数据,需要在循环中手动处理时间步。

seqLen:每个句子所含词的个数
batchSize:每次处理词的批数
InputSize:每个词嵌入向量的位数
dataset: (seq_size, batch_size, input_size)——>整个数据集维度
input: (batch_size, input_size)——>每个时间步处理的输入(input in dataset)
hidden: (batch_size, output_size)——>每次处理的隐层(即为output)
import torchbatch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2# Construction of RNNCell
cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size)
# Wrapping the sequence into:(seqLen,batchSize,InputSize)
dataset = torch.randn(seq_len, batch_size, input_size)  # (3,1,4)
# Initializing the hidden to zero
hidden = torch.zeros(batch_size, hidden_size)  # (1,2)for idx, input in enumerate(dataset):print('=' * 20, idx, '=' * 20)print('Input size:', input.shape)  # (batch_size, input_size)# 按序列依次输入到cell中,seq_len=3,故循环3次hidden = cell(input, hidden)  # 返回的hidden是下一次的输入之一,循环使用同一个cellprint('output size:', hidden.shape)  # (batch_size, hidden_size)print(hidden.data)

Wih的size应该是(hidden * input),whh的size应该是(hidden * hidden):输入 * 一个权重和上一个隐藏层 * 一个权重。w1 * h + w2 * x = [w1 w2] [h x]^T,也就是(h * (h+i)) * (h + i) * 1 = h * 1的矩阵 然后丢到tanh()里去计算

在这里插入图片描述

写成下面公式
h t = t a n h ( W i h x t + b i h + W h h h t − 1 + b h h ) h_t=tanh(W_{ih}x_t+b_{ih}+W_{hh}h_{t-1}+b_{hh}) ht=tanh(Wihxt+bih+Whhht1+bhh)

如果使用rnncell主要用下面代码,需要输入维度和隐藏层维度作为函数输入

在这里插入图片描述

import torchbatch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size)
# #(seqLen, batchSize, inputSize)
datasets = torch.randn(seq_len, batch_size, input_size)
hidden = torch.zeros(batch_size, hidden_size)for idx, input in enumerate(datasets):print("=" * 20, idx, "=" * 20)print("input size:", input.shape)hidden= cell(input, hidden)print("output size:", hidden.shape)print(hidden)

Train a model to learn: “hello” -> “ohlol”

基于RNNCell实现

在这里插入图片描述

先给每个字母编号(索引),然后对于’hello’序列写出其对应的序列表,将表展开成一个独热向量,出现的位置是1,其他位置是0

在这里插入图片描述

每个字母相当于一个独热向量送进去,输出是一个四维向量,经过softmax输出概率最大的值,在本题里应该是"ohlol" -》 “31232”

在这里插入图片描述

总代码

import torch# 输入样本特征数
input_size = 4
# 隐藏层样本特征数(分类数)
hidden_size = 4
# batch大小
batch_size = 1idx2char = ['e', 'h', 'l', 'o']
# hello
x_data = [1, 0, 2, 2, 3]#输入字典
# ohlol
y_data = [3, 1, 2, 3, 2]#输出词典# 将x_data转换为one_hot表示
'''
torch.eye()
参数:
n (int ) – 行数
m (int, optional) – 列数.如果为None,则默认为n
out (Tensor, optinal) - Output tensor
'''
x_one_hot = torch.eye(n=4)[x_data, :]
y_one_hot = torch.eye(n=4)[y_data, :]# x_data转换维度为(seqlen, batch_size, input_size),此维度为RNN的输入
inputs = x_one_hot.view(-1, batch_size, input_size)
# y_data转换维度为(seqlen,1)
labels = torch.LongTensor(y_data).view(-1, 1)# 构建神经网络模型
class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.input_size = input_sizeself.batch_size = batch_sizeself.hidden_size = hidden_size# 对于RNNCell输入为(batch_size, input_size),隐层为(batch_size, hidden_size)self.rnncell = torch.nn.RNNCell(input_size=self.input_size, hidden_size=self.hidden_size)def forward(self, input, hidden):# h_t=Cell(x_t, h_t-1)hidden = self.rnncell(input, hidden)return hidden# 初始化隐层h_0def init_hidden(self):return torch.zeros(self.batch_size, self.hidden_size)model = Model()# 构建损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)# 训练
for epoch in range(60):loss = 0optimizer.zero_grad()# h_0hidden = model.init_hidden()print('Predicted string:', end='')for input, label in zip(inputs, labels):hidden = model(input, hidden)loss += criterion(hidden, label)_, idx = hidden.max(dim=1)print(idx2char[idx.item()], end='')loss.backward()optimizer.step()print(', epoch[%d/60] loss=%.4f' % (epoch+1, loss.item()))

基于RNN实现

RNN需要输入三个参数:input_size, hidden_size, num_layers

在这里插入图片描述

输入:input的shape(seqSize, batch, input_size)

hidden的shape(numLayers, batch, hidden_size)

输出:output的shape(seqSize, batch, hidden_size)

hidden的shape(numLayers, batch, hidden_size)

在这里插入图片描述

import torchbatch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2
num_layers =1cell = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True)#(seqLen, batchSize, inputSize)
inputs = torch.randn(batch_size, seq_len, input_size)
hidden = torch.zeros(num_layers, batch_size, hidden_size)out, hidden = cell(inputs, hidden)
print("output size:", out.shape)
print("output:", out)
print("hidden size:", hidden.shape)
print("hidden:", hidden)

总代码

import torch# 1.参数设置
seq_len = 5
input_size = 4
hidden_size = 4
batch_size = 1# 2.数据准备
index2char = ['e', 'h', 'l', 'o']
x_data = [1, 0, 2, 2, 3]
y_data = [3, 1, 2, 3, 2]
one_hot_lookup = [[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1]]
x_one_hot = [one_hot_lookup[x] for x in x_data]
inputs = torch.Tensor(x_one_hot).view(-1, batch_size, input_size)
labels = torch.LongTensor(y_data)# 3.模型构建
class Model(torch.nn.Module):def __init__(self, input_size, hidden_size, batch_size, num_layers=1):  # 需要指定输入,隐层,批super(Model, self).__init__()self.batch_size = batch_sizeself.input_size = input_sizeself.hidden_size = hidden_sizeself.num_layers = num_layersself.rnn = torch.nn.RNN(input_size=self.input_size, hidden_size=self.hidden_size, num_layers=self.num_layers)def forward(self, input):hidden = torch.zeros(self.num_layers,self.batch_size,self.hidden_size)out, _ = self.rnn(input, hidden)  # out: tensor of shape (seq_len, batch, hidden_size)return out.view(-1, self.hidden_size)  # 将输出的三维张量转换为二维张量,(𝒔𝒆𝒒𝑳𝒆𝒏×𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒉𝒊𝒅𝒅𝒆𝒏𝑺𝒊𝒛𝒆)net = Model(input_size, hidden_size, batch_size)# 4.损失和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.5)# 5.训练
for epoch in range(15):optimizer.zero_grad()outputs = net(inputs)print(outputs.shape)loss = criterion(outputs, labels)loss.backward()optimizer.step()_, idx = outputs.max(dim=1)idx = idx.data.numpy()print('Predicted string: ', ''.join([index2char[x] for x in idx]), end='')print(',Epoch [%d / 15] loss:%.4f' % (epoch+1, loss.item()))

one-hot的缺点:高维、稀疏、硬编码

需求:低维、稠密、从数据中学习

实现方法:embedding

含嵌入层的RNN网络

from gpt4o:

含嵌入层的RNN网络是结合嵌入层(Embedding Layer)和循环神经网络(RNN)的一种神经网络架构,常用于自然语言处理(NLP)任务。嵌入层的主要作用是将离散的词汇映射到连续的向量空间中,从而为RNN提供密集的、低维的输入表示,这比直接使用稀疏的one-hot编码更为高效。

嵌入层的作用

嵌入层将词汇表中的每个词映射到一个固定维度的向量。它的主要优点包括:

  1. 降低维度:从高维的one-hot编码(词汇表大小)转换为低维的密集向量表示。
  2. 捕捉语义关系:相似的词在嵌入空间中往往具有相近的向量表示,从而能够捕捉词与词之间的语义关系。

含嵌入层的RNN网络架构

一个典型的含嵌入层的RNN网络架构包括以下几个部分:

  1. 嵌入层:将输入的词汇索引序列转换为嵌入向量序列。
  2. RNN层:处理嵌入向量序列,捕捉序列中的时序依赖关系。
  3. 输出层:根据任务的不同,可以是分类层、回归层等,用于生成最终的预测结果。

以下是一个含嵌入层的RNN网络的具体代码示例和详细解释:

import torch
import torch.nn as nn# 定义超参数
vocab_size = 10      # 词汇表大小
embed_size = 8       # 嵌入向量的维度
hidden_size = 16     # RNN隐藏层的维度
output_size = 5      # 输出层的大小(例如类别数)
num_layers = 1       # RNN的层数# 定义含嵌入层的RNN模型
class RNNModelWithEmbedding(nn.Module):def __init__(self, vocab_size, embed_size, hidden_size, output_size, num_layers=1):super(RNNModelWithEmbedding, self).__init__()self.embedding = nn.Embedding(vocab_size, embed_size)   # 嵌入层self.rnn = nn.RNN(embed_size, hidden_size, num_layers, batch_first=True)self.fc = nn.Linear(hidden_size, output_size)           # 全连接层,输出最终结果def forward(self, x):embedded = self.embedding(x)         # 输入序列通过嵌入层out, hidden = self.rnn(embedded)     # 嵌入向量序列通过RNN层out = self.fc(out[:, -1, :])         # 取RNN的最后一个时间步的输出,经过全连接层return out# 创建模型实例
model = RNNModelWithEmbedding(vocab_size, embed_size, hidden_size, output_size, num_layers)# 打印模型结构
print(model)# 创建随机输入,形状为(batch_size, seq_len)
input_data = torch.randint(0, vocab_size, (2, 3))  # 例如 batch_size=2, seq_len=3# 前向传播
output = model(input_data)print("输入:", input_data)
print("输出:", output)

嵌入层self.embedding = nn.Embedding(vocab_size, embed_size)

  • vocab_size:词汇表的大小,即词汇数量。
  • embed_size:每个词的嵌入向量的维度。
  • 嵌入层的作用是将输入的词汇索引序列(如[1, 2, 3])转换为嵌入向量序列。

RNN层self.rnn = nn.RNN(embed_size, hidden_size, num_layers, batch_first=True)

  • embed_size:RNN的输入维度,即嵌入向量的维度。
  • hidden_size:RNN隐藏层的维度。
  • num_layers:RNN的层数。
  • batch_first=True:输入和输出的形状为(batch_size, seq_len, feature_size)

全连接层self.fc = nn.Linear(hidden_size, output_size)

  • hidden_size:RNN隐藏层的维度。
  • output_size:输出层的大小,例如分类任务中的类别数。
  • 全连接层的作用是将RNN的输出转换为最终的预测结果。

前向传播函数def forward(self, x)

  • 输入x是词汇索引序列(形状为(batch_size, seq_len))。
  • 通过嵌入层将输入序列转换为嵌入向量序列embedded
  • 嵌入向量序列通过RNN层得到输出out和隐藏状态hidden
  • 取RNN层最后一个时间步的输出out[:, -1, :],通过全连接层得到最终输出out

gpt结束

在下面加一层embed层

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, sparse=False)
"""
参数解释
num_embeddings:嵌入字典的大小,即词汇表的大小。比如,如果有 10000 个不同的单词,那么 num_embeddings 就是 10000。
embedding_dim:每个嵌入向量的维度。比如,如果希望每个单词表示为 128 维的向量,那么 embedding_dim 就是 128。
padding_idx (可选):如果指定了这个参数,那么这个索引将在计算梯度时总是返回零向量,并且其对应的嵌入向量不会更新。这个通常用于处理填充(padding)。
max_norm (可选):如果指定了这个参数,每个嵌入向量的范数(norm)将不会超过这个值。如果某个嵌入向量的范数超过了 max_norm,那么它将被重新缩放到 max_norm。
norm_type (可选):用于计算范数的类型。默认为2(L2范数)。
scale_grad_by_freq (可选):如果设为 True,则根据单词在小批量中的频率来缩放梯度。
sparse (可选):如果设为 True,则使用稀疏更新。
"""

当使用嵌入层(torch.nn.Embedding)作为 RNN 的输入时,输入张量通常需要是长整型(torch.LongTensor,因为嵌入层的输入是索引,索引通常以长整型表示。嵌入层将这些索引映射到相应的嵌入向量,然后这些嵌入向量可以作为 RNN 的输入。

在这里插入图片描述

在这里插入图片描述

总代码

import torch# 1、确定参数
num_class = 4
input_size = 4
hidden_size = 8
embedding_size = 10
num_layers = 2
batch_size = 1
seq_len = 5# 2、准备数据
index2char = ['e', 'h', 'l', 'o']  # 字典
x_data = [[1, 0, 2, 2, 3]]  # (batch_size, seq_len) 用字典中的索引(数字)表示来表示hello
y_data = [3, 1, 2, 3, 2]  # (batch_size * seq_len) 标签:ohlolinputs = torch.LongTensor(x_data)  # (batch_size, seq_len)
labels = torch.LongTensor(y_data)  # (batch_size * seq_len)# 3、构建模型
class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.emb = torch.nn.Embedding(num_class, embedding_size)self.rnn = torch.nn.RNN(input_size=embedding_size, hidden_size=hidden_size, num_layers=num_layers,batch_first=True)self.fc = torch.nn.Linear(hidden_size, num_class)def forward(self, x):hidden = torch.zeros(num_layers, x.size(0), hidden_size)  # (num_layers, batch_size, hidden_size)x = self.emb(x)  # 返回(batch_size, seq_len, embedding_size)x, _ = self.rnn(x, hidden)  # 返回(batch_size, seq_len, hidden_size)x = self.fc(x)  # 返回(batch_size, seq_len, num_class)return x.view(-1, num_class)  # (batch_size * seq_len, num_class)net = Model()# 4、损失和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)  # Adam优化器# 5、训练
for epoch in range(15):optimizer.zero_grad()outputs = net(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()_, idx = outputs.max(dim=1)idx = idx.data.numpy()print('Predicted string: ', ''.join([index2char[x] for x in idx]), end='')print(', Epoch [%d/15] loss: %.4f' % (epoch + 1, loss.item()))

其他RNN扩展

  1. LSTM(长短期记忆网络)
    • LSTM通过引入细胞状态和门控机制(输入门、遗忘门和输出门)来保留和控制长期依赖信息。
    • 解决了标准RNN在处理长序列时的梯度消失问题。
import torch
import torch.nn as nnclass LSTMModel(nn.Module):def __init__(self, input_size, hidden_size, batch_size, num_layers=1):super(LSTMModel, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.lstm = nn.LSTM(input_size, hidden_size, num_layers)def forward(self, input):h0 = torch.zeros(self.num_layers, input.size(1), self.hidden_size)c0 = torch.zeros(self.num_layers, input.size(1), self.hidden_size)out, _ = self.lstm(input, (h0, c0))return out.view(-1, self.hidden_size)
  1. GRU(门控循环单元)
  • GRU是LSTM的简化版本,使用更新门和重置门来控制信息的流动。
  • 与LSTM相比,GRU的参数较少,因此计算效率更高。
import torch
import torch.nn as nnclass GRUModel(nn.Module):def __init__(self, input_size, hidden_size, batch_size, num_layers=1):super(GRUModel, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.gru = nn.GRU(input_size, hidden_size, num_layers)def forward(self, input):h0 = torch.zeros(self.num_layers, input.size(1), self.hidden_size)out, _ = self.gru(input, h0)return out.view(-1, self.hidden_size)
  1. Bidirectional RNN(双向RNN)
  • 双向RNN在输入序列的两个方向(正向和反向)上进行训练,从而捕获更多的上下文信息。
  • 可以用于LSTM和GRU。
python复制代码import torch
import torch.nn as nnclass BidirectionalLSTMModel(nn.Module):def __init__(self, input_size, hidden_size, batch_size, num_layers=1):super(BidirectionalLSTMModel, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.lstm = nn.LSTM(input_size, hidden_size, num_layers, bidirectional=True)def forward(self, input):h0 = torch.zeros(self.num_layers * 2, input.size(1), self.hidden_size)c0 = torch.zeros(self.num_layers * 2, input.size(1), self.hidden_size)out, _ = self.lstm(input, (h0, c0))return out.view(-1, self.hidden_size * 2)
  1. Attention Mechanism(注意力机制)
  • 注意力机制用于在处理序列时动态地关注重要部分。
  • 常用于提高序列到序列模型(如机器翻译)的性能。
python复制代码import torch
import torch.nn as nnclass AttentionModel(nn.Module):def __init__(self, input_size, hidden_size, batch_size, num_layers=1):super(AttentionModel, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.lstm = nn.LSTM(input_size, hidden_size, num_layers)self.attention = nn.Linear(hidden_size, hidden_size)def forward(self, input):h0 = torch.zeros(self.num_layers, input.size(1), self.hidden_size)c0 = torch.zeros(self.num_layers, input.size(1), self.hidden_size)out, _ = self.lstm(input, (h0, c0))attn_weights = torch.softmax(self.attention(out), dim=1)out = torch.bmm(attn_weights.transpose(1, 2), out)return out.view(-1, self.hidden_size)

这些RNN变体在不同的应用中各有优势,选择适当的变体可以显著提高模型的性能。

注意力机制(Attention Mechanism)是深度学习中一种强大的技术,尤其在自然语言处理(NLP)任务中。它允许模型在处理序列数据时动态地关注序列的不同部分,从而捕捉更丰富的上下文信息。以下是一些关于注意力机制的详细信息和其主要变体。

基本注意力机制

基本的注意力机制可以用在编码器-解码器结构中,以动态地聚焦在输入序列的不同部分。下面是一个简单的注意力机制示例:

python复制代码import torch
import torch.nn as nnclass BasicAttention(nn.Module):def __init__(self, hidden_size):super(BasicAttention, self).__init__()self.attention = nn.Linear(hidden_size, hidden_size)def forward(self, encoder_outputs, decoder_hidden):# 计算注意力权重attn_weights = torch.bmm(encoder_outputs, decoder_hidden.unsqueeze(2)).squeeze(2)attn_weights = torch.softmax(attn_weights, dim=1)# 用注意力权重加权平均编码器输出context = torch.bmm(attn_weights.unsqueeze(1), encoder_outputs).squeeze(1)return context, attn_weights

自注意力机制(Self-Attention)

自注意力机制用于捕获序列中各位置之间的关系,尤其适用于序列到序列任务。它是Transformer模型的核心组件。

自注意力计算

自注意力计算涉及三个矩阵:查询矩阵(Query)、键矩阵(Key)和值矩阵(Value)。下面是自注意力计算的公式:

Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V Attention(Q,K,V)=softmax(dk QKT)V

python复制代码import torch
import torch.nn as nnclass SelfAttention(nn.Module):def __init__(self, input_size, hidden_size):super(SelfAttention, self).__init__()self.query = nn.Linear(input_size, hidden_size)self.key = nn.Linear(input_size, hidden_size)self.value = nn.Linear(input_size, hidden_size)self.scale = torch.sqrt(torch.FloatTensor([hidden_size]))def forward(self, x):Q = self.query(x)K = self.key(x)V = self.value(x)attention_weights = torch.bmm(Q, K.transpose(1, 2)) / self.scaleattention_weights = torch.softmax(attention_weights, dim=-1)context = torch.bmm(attention_weights, V)return context, attention_weights

多头注意力机制(Multi-Head Attention)

多头注意力机制是自注意力的扩展,它通过多个注意力头(head)来捕获不同的特征子空间。每个头独立地执行自注意力,然后将所有头的输出连接起来。

import torch
import torch.nn as nnclass MultiHeadAttention(nn.Module):def __init__(self, input_size, hidden_size, num_heads):super(MultiHeadAttention, self).__init__()self.num_heads = num_headsself.hidden_size = hidden_sizeself.query = nn.Linear(input_size, hidden_size * num_heads)self.key = nn.Linear(input_size, hidden_size * num_heads)self.value = nn.Linear(input_size, hidden_size * num_heads)self.fc = nn.Linear(hidden_size * num_heads, hidden_size)def forward(self, x):batch_size = x.size(0)Q = self.query(x).view(batch_size, -1, self.num_heads, self.hidden_size).transpose(1, 2)K = self.key(x).view(batch_size, -1, self.num_heads, self.hidden_size).transpose(1, 2)V = self.value(x).view(batch_size, -1, self.num_heads, self.hidden_size).transpose(1, 2)attention_weights = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.FloatTensor([self.hidden_size]))attention_weights = torch.softmax(attention_weights, dim=-1)context = torch.matmul(attention_weights, V).transpose(1, 2).contiguous().view(batch_size, -1, self.hidden_size * self.num_heads)output = self.fc(context)return output, attention_weights

Transformer模型

Transformer模型是基于自注意力和多头注意力机制的架构。它广泛应用于NLP任务,并通过引入位置编码(Positional Encoding)解决了序列位置问题。

简单的Transformer编码器

class TransformerEncoder(nn.Module):def __init__(self, input_size, hidden_size, num_heads, num_layers):super(TransformerEncoder, self).__init__()self.layers = nn.ModuleList([nn.TransformerEncoderLayer(hidden_size, num_heads) for _ in range(num_layers)])self.embedding = nn.Linear(input_size, hidden_size)def forward(self, src):src = self.embedding(src)for layer in self.layers:src = layer(src)return src

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/379863.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

RPC与服务的注册发现

文章目录 1. 什么是远程过程调用(RPC)?2. RPC的流程3. RPC实践4. RPC与REST的区别4.1 RPC与REST的相似之处4.2 RPC与REST的架构原则4.3 RPC与REST的主要区别 5. RPC与服务发现5.1 以zookeeper为服务注册中心5.2 以etcd为服务注册中心 6. 小结参考 1. 什么是远程过程调用(RPC)?…

TCP三次握手与四次挥手详解

1.什么是TCP TCP(Transmission Control Protocol,传输控制协议)是一种面向连接的、可靠的、基于字节流的通信协议,属于互联网协议族(TCP/IP)的一部分。TCP 提供可靠的、顺序的、无差错的数据传输服务&…

win11家庭版怎么升级专业版

随着Windows 11的推出,许多用户享受到了全新的用户界面和功能。然而,Windows 11家庭版在某些高级功能上有所限制,例如,组策略管理、远程桌面连接等。为了满足更多的工作需求,许多用户希望将Windows 11家庭版升级到专业…

十、Java集合 ★ ✔(模块18-20)【泛型、通配符、List、Set、TreeSet、自然排序和比较器排序、Collections、可变参数、Map】

day05 泛型,数据结构,List,Set 今日目标 泛型使用 数据结构 List Set 1 泛型 1.1 泛型的介绍 ★ 泛型是一种类型参数,专门用来保存类型用的 最早接触泛型是在ArrayList,这个E就是所谓的泛型了。使用ArrayList时,只要给E指定某一个类型…

分布式IO系统BL201 Profinet耦合器

BL201耦合器是一个数据采集和控制系统,基于强大的32 位微处理器设计,采用Linux操作系统,是一种模块化的分布式I/O系统。该系统由3部分组成:现场总线耦合器和各种类型的(数字和模拟信号以及特殊功能)I/O模块…

Keka for Mac v1.4.3 中文下载 解压/压缩工具

Mac分享吧 文章目录 效果一、下载软件二、开始安装1、双击运行软件,将其从左侧拖入右侧文件夹中,等待安装完毕2、应用程序显示软件图标,表示安装成功 三、运行测试1、打开软件2、文件访问权限修改3、访达扩展 安装完成!&#xff…

Ubantu 使用 docker 配置 + 远程部署 + 远程开发

大家好我是苏麟 , Ubantu 一些配置 . 视频 : 服务器很贵?搞台虚拟机玩玩!保姆级 Linux 远程开发教程_哔哩哔哩_bilibili Docker安装及配置 安装命令 : sudo apt install docker.io 查看版本号 : docker -v 查看虚拟机地址命令 : ifconfig 虚拟机地址 或…

【Android】 dp与sp,加冕为王

目录 重要概念 屏幕尺寸 屏幕分辨率 屏幕像素密度 基础知识: ppi pt DPI 的定义和重要性 Android 中的 DPI 级别 px dp(Density Independent Pixels) sp(Scale-independent Pixels) 安卓的dp/dip、sp 虚拟…

PlantUML-UML 绘图工具安装、Graphviz安装、本地使用/在线使用、语法、图示案例

文章目录 前言本地安装vscode安装插件下载安装Graphviz配置Graphviz环境变量测试 在线使用演示PlantUML语法总结活动图(新语法)时序图类图用例图其他图 更多相关内容可查看 前言 本篇提供两种使用方式分别为 在线使用地址1:https://www.pla…

【日常记录】【插件】excel.js导出的时候给单元格设置下拉选择、数据校验等

文章目录 1. 代码基本结构2. 导出的excel 某单元格的值设置为下拉选择3. 如何把下拉选择项设置为动态4. 单元格设置校验、提示5. 在WPS上的设置 1. 代码基本结构 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><…

Gitee使用教程2-克隆仓库(下载项目)并推送更新项目

一、下载 Gitee 仓库 1、点击克隆-复制代码 2、打开Git Bash 并输入复制的代码 下载好后&#xff0c;找不到文件在哪的可以输入 pwd 找到仓库路径 二、推送更新 Gitee 项目 1、打开 Git Bash 用 cd 命令进入你的仓库&#xff08;我的仓库名为book&#xff09; 2、添加文件到 …

容器化部署prometheus后再监控docker容器

一、主机部署Prometheus、cadvisor、grafana、node-exporter 1、部署cadvisor收集节点容器信息 docker run -v /:/rootfs:ro -v /var/run:/var/run/:rw -v /sys:/sys:ro -v /var/lib/docker:/var/lib/docker:ro -p 8080:8080 --detachtrue --namecadvisor google/cadvisor 2、…

在线 PDF 制作者泄露用户上传的文档

两家在线 PDF 制作者泄露了数万份用户文档&#xff0c;包括护照、驾驶执照、证书以及用户上传的其他个人信息。 我们都经历过这样的情况&#xff1a;非常匆忙&#xff0c;努力快速制作 PDF 并提交表单。许多人向在线 PDF 制作者寻求帮助&#xff0c;许多人的祈祷得到了回应。 …

PolarisMesh源码系列--Polaris-Go注册发现流程

导语 北极星是腾讯开源的一款服务治理平台&#xff0c;用来解决分布式和微服务架构中的服务管理、流量管理、配置管理、故障容错和可观测性问题。在分布式和微服务架构的治理领域&#xff0c;目前国内比较流行的还包括 Spring Cloud&#xff0c;Apache Dubbo 等。在 Kubernete…

golang开发环境搭建与踩坑记录

文章目录 一、安装下载1、go环境2、ide 二、基本使用1、运行2、结构体与方法函数指针3、闭包4、指针5、map6、接口7、异常 三、包管理1、go mod语法2、项目下载所有依赖 一、安装下载 1、go环境 下载地址&#xff1a;https://go.dev/dl/ 或者&#xff1a;https://golang.goog…

算法基础之回溯法

本文将详细介绍回溯法的基本原理和适用条件&#xff0c;并通过经典例题辅助读者理解回溯法的思想、掌握回溯法的使用。本文给出的例题包括&#xff1a;N皇后问题、子集和问题。 算法原理 在问题的解空间树中&#xff0c;回溯法按照深度优先的搜索策略&#xff0c;从根结点出发…

[开源]语雀+Vercel:打造免费个人博客网站

大家好,我是白露。 今天我想和大家分享我的今年的第一个开源项目 —— 基于语雀+Nextjs+Vercel实现免费的博客系统。 简单来说,你在语雀写博客,然后直接一键同步到个人网站上,网站自动部署! 而且,整个过程几乎不需要额外的成本,也不用充值语雀超级会员,hh。这个项目…

Teamviewer删除可信任设备

目前基本上主流的远程连接软件都有限制&#xff0c;要么收费&#xff1b; Teamviewer可信任设备有限&#xff0c;超出限制就会提示错误&#xff0c;需要删除多余的设备才能登陆账号&#xff01; 需要登陆这个网站 Teamviewer Management console&#xff0c;才能修改&#xff…

FastAPI -- 第三弹(自定义响应、中间件、代理、WebSockets)

路径操作的高级配置 OpenAPI 的 operationId from fastapi import FastAPIapp FastAPI()# 通过 operation_id 参数设置 app.get("/items/", operation_id"some_specific_id_you_define") async def read_items():return [{"item_id": "F…

【C语言】全面解析冒泡排序

文章目录 什么是冒泡排序&#xff1f;冒泡排序的基本实现代码解释冒泡排序的优化冒泡排序的性能分析冒泡排序的实际应用结论 在C语言编程中&#xff0c;排序算法是一个非常基础且重要的概念。冒泡排序作为最简单、最易理解的排序算法之一&#xff0c;广泛应用于各种编程教学和实…