Basic RNN

文章目录

  • 回顾
  • RNN
    • RNN Cell
    • RNNCell的使用
    • RNN的使用
  • RNN例子
    • 使用RNN Cell实现
    • 使用RNN实现
  • 嵌入层 Embedding
    • 独热向量的缺点
    • Embedding
  • LSTM
  • GRU(门控循环单元)
  • 练习

回顾

DNN（全连接）：和CNN相比，拥有巨大的参数量，CNN权重共享因此参数量小很多。
在这里插入图片描述

RNN

RNN Cell

RNN主要是处理带有时间序列特征的数据（前后文拥有逻辑关系）

  • 自然语言：依赖于词的顺序
    在这里插入图片描述

以上的RNN cell为同一个线形层（处理一个序列），其实以上是一个循环：
在这里插入图片描述
RNN Cell具体计算过程如下：
在这里插入图片描述
在这里插入图片描述

RNNCell的使用

在这里插入图片描述
在这里插入图片描述

假设有以下这些条件：在这里插入图片描述
RNNCell的输入、输出的维度就应该是：
在这里插入图片描述
数据集的形状应该是：
在这里插入图片描述

seqLen应该放在最前面，方便循环。

#练习1
import torch

batch_size=1
seq_len=3
input_size=4
hidden_size=2

#构建RNNcell，RNNcell本质是一个Linear层
cell=torch.nn.RNNCell(input_size=input_size,hidden_size=hidden_size)

#(seq,batch,feartures)
#产生形状为(seq_len,batch_size,input_size)的序列
dataset= torch.randn(seq_len,batch_size,input_size)

#初始化hidden为0
hidden =torch.zeros(batch_size,hidden_size)

for idx, input in enumerate (dataset):#遍历datset中的序列
    print('='*20,'='*20)
    print('Input size:',input.shape)#[1, 4]

    hidden=cell(input,hidden)#上一个的output作为下一个的hidden

    print('output size:',hidden.shape) #[1, 2]，output size=hidden size,上一个的output作为下一个的hidden
    print(hidden)

结果：

==================== ====================
Input size: torch.Size([1, 4])
output size: torch.Size([1, 2])
tensor([[-0.4549,  0.6699]], grad_fn=<TanhBackward0>)
==================== ====================
Input size: torch.Size([1, 4])
output size: torch.Size([1, 2])
tensor([[-0.7693,  0.1919]], grad_fn=<TanhBackward0>)
==================== ====================
Input size: torch.Size([1, 4])
output size: torch.Size([1, 2])
tensor([[0.2945, 0.8171]], grad_fn=<TanhBackward0>)

RNN的使用

在这里插入图片描述

inputs:全部的输入序列；shape=(𝑠𝑒𝑞𝑆𝑖𝑧𝑒,𝑏𝑎𝑡𝑐ℎ,𝑖𝑛𝑝𝑢𝑡_𝑠𝑖𝑧𝑒)
out:全部的隐层输出;shape=(𝑠𝑒𝑞𝐿𝑒𝑛,𝑏𝑎𝑡𝑐ℎ,ℎ𝑖𝑑𝑑𝑒𝑛_𝑠𝑖𝑧𝑒)
hidden：最后一层的隐层输出;shape=(𝑛𝑢𝑚𝐿𝑎𝑦𝑒𝑟𝑠,𝑏𝑎𝑡𝑐ℎ,ℎ𝑖𝑑𝑑𝑒𝑛_𝑠𝑖𝑧𝑒)

需要的参数：
• 𝑏𝑎𝑡𝑐ℎ𝑆𝑖𝑧𝑒
• 𝑠𝑒𝑞𝐿𝑒𝑛
• 𝑖𝑛𝑝𝑢𝑡𝑆𝑖𝑧𝑒,ℎ𝑖𝑑𝑑𝑒𝑛𝑆𝑖𝑧𝑒,
• 𝑛𝑢𝑚𝐿𝑎𝑦𝑒𝑟𝑠

在这里插入图片描述

同一层的RNN Cell是同一个，以上其实只有3层。

在这里插入图片描述

# 练习2
import torch

batch_size=1
seq_len=3
input_size=4
hidden_size=2
num_layers=1

#Construction of RNN
cell=torch.nn.RNN(input_size,hidden_size,num_layers)
cell1=torch.nn.RNN(input_size,hidden_size,num_layers,batch_first=True)

#(seq,batch,inputSize)
inputs= torch.randn(seq_len,batch_size,input_size)
inputs1=torch.randn(batch_size,seq_len,input_size)

#初始化hidden为0
hidden =torch.zeros(num_layers,batch_size,hidden_size)


out,hidden=cell(inputs,hidden)
# out,hidden=cell1(inputs1,hidden)

print('Output size:',out.shape)#The shape of output is:[𝒔𝒆𝒒𝑺𝒊𝒛𝒆, 𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆, 𝒉𝒊𝒅𝒅𝒆𝒏𝑺𝒊𝒛]
print('Output:',out)
print('Hidden size:',hidden.shape)#The shape of hidden is:[𝒏𝒖𝒎𝑳𝒂𝒚𝒆𝒓𝒔, 𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆, 𝒉𝒊𝒅𝒅𝒆𝒏𝑺𝒊𝒛]
print("Hidden",hidden)

注意：在这里插入图片描述

batch_first=True:输入数据的batch_size需要放在最前面。很多时候batch需要放在最前面。

结果：

Output size: torch.Size([3, 1, 2])
Output: tensor([[[ 0.7220, -0.1743]],
        [[-0.2194, -0.1024]],
        [[ 0.5668, -0.0651]]], grad_fn=<StackBackward0>)
Hidden size: torch.Size([1, 1, 2])
Hidden tensor([[[ 0.5668, -0.0651]]], grad_fn=<StackBackward0>)

RNN例子

训练一个模型将：“hello” ->“ohlol”（seq to seq）

使用RNN Cell实现

在这里插入图片描述

  • RNNcell的输入应该是一组向量，我们需要将序列进行转换，转换为独热向量（One-Hot Vectors）：
    在这里插入图片描述
    在这里插入图片描述

RNNCell结果通过softmax转化为多分类问题，然后计算交叉熵损失。

#练习3 use RNNCell
import torch
# parameters
hidden_size = 4
input_size = 4
batch_size = 1
idx2char = ['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]#将x的索引转换为独热向量
inputs=torch.Tensor(x_one_hot).view(-1,batch_size,input_size)#(𝒔𝒆𝒒𝑳𝒆𝒏,𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)
labels=torch.LongTensor(y_data).view(-1,1)#(𝒔𝒆𝒒𝑳𝒆𝒏,𝟏)
class Model(torch.nn.Module):
    def __init__(self,input_size,hidden_size,batch_size):
        super(Model, self).__init__()
        #初始化参数
        self.batch_size=batch_size
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.rnncell=torch.nn.RNNCell(input_size=input_size,#(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)
                                      hidden_size=hidden_size)#(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒉𝒊𝒅𝒅𝒆𝒏𝑺𝒊𝒛𝒆)

    def forward(self, input,hidden):
        hidden=self.rnncell(input,hidden)
        return hidden
    def init_hidden(self):
        return torch.zeros(self.batch_size,self.hidden_size)#初始化隐藏层

net=Model(input_size,hidden_size,batch_size)

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.1)

#训练
for epoch in range(15):
    loss=0
    optimizer.zero_grad()#梯度清零
    hidden=net.init_hidden()
    print("Predicted string:",end='')
    # input:(𝒔𝒆𝒒𝑳𝒆𝒏,𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)->input:(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)
    for input,label in zip(inputs,labels):
        hidden=net(input,hidden)#RNNcell
        loss+=criterion(hidden,label)
        _,idx=hidden.max(dim=1)
        print(idx2char[idx.item()],end='')

    loss.backward()#backward
    optimizer.step()#更新

    print(', Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

结果：

Predicted string:ooool, Epoch [1/15] loss = 5.873
Predicted string:ooool, Epoch [2/15] loss = 5.184
Predicted string:oooll, Epoch [3/15] loss = 5.083
Predicted string:oolll, Epoch [4/15] loss = 4.925
Predicted string:ollll, Epoch [5/15] loss = 4.669
Predicted string:ollll, Epoch [6/15] loss = 4.335
Predicted string:oooll, Epoch [7/15] loss = 4.070
Predicted string:oholl, Epoch [8/15] loss = 3.936
Predicted string:oholl, Epoch [9/15] loss = 3.841
Predicted string:oholl, Epoch [10/15] loss = 3.739
Predicted string:ohlll, Epoch [11/15] loss = 3.635
Predicted string:ohlll, Epoch [12/15] loss = 3.541
Predicted string:ohlll, Epoch [13/15] loss = 3.459
Predicted string:ohlll, Epoch [14/15] loss = 3.380
Predicted string:ohlll, Epoch [15/15] loss = 3.298

使用RNN实现

#练习4 use RNN
import torch
# parameters
input_size = 4
hidden_size = 4
num_layers = 1
batch_size = 1
seq_len = 5
idx2char = ['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]#将x的索引转换为独热向量
inputs=torch.Tensor(x_one_hot).view(seq_len,batch_size,input_size)#(𝒔𝒆𝒒𝑳𝒆𝒏,𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)
labels=torch.LongTensor(y_data)#(𝒔𝒆𝒒𝑳𝒆𝒏×𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝟏)变成二维矩阵，方便使用交叉熵损失计算
class Model(torch.nn.Module):
    def __init__(self,input_size, hidden_size,batch_size,num_layers=1):
        super(Model, self).__init__()
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.batch_size=batch_size
        self.num_layers=num_layers
        self.rnn = torch.nn.RNN(input_size=input_size,
                                hidden_size=hidden_size,
                                num_layers=num_layers)



    def forward(self, input):
        #hidden:(𝒏𝒖𝒎𝑳𝒂𝒚𝒆𝒓𝒔,𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒉𝒊𝒅𝒅𝒆𝒏𝑺𝒊𝒛𝒆) 初始化隐层
        hidden=torch.zeros(self.num_layers,
                           self.batch_size,
                           self.hidden_size)
        out,_=self.rnn(input,hidden)
        return out.view(-1,self.hidden_size)
        #reshape:(𝒔𝒆𝒒𝑳𝒆𝒏×𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒉𝒊𝒅𝒅𝒆𝒏𝑺𝒊𝒛𝒆)：变成二维矩阵，方便使用交叉熵损失计算

net = Model(input_size,hidden_size,batch_size,num_layers)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)
for epoch in range(15):
    #Training step
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()
    # _,idx = outputs.max(dim=1)
    # idx = idx.data.numpy()
    idx = outputs.argmax(dim=1)
    idx=idx.data.numpy()
    print('Predicted: ', ''.join([idx2char[x] for x in idx]), end='')
    print(', Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

结果：

Predicted:  eeeee, Epoch [1/15] loss = 1.440
Predicted:  oelll, Epoch [2/15] loss = 1.304
Predicted:  oelll, Epoch [3/15] loss = 1.183
Predicted:  ohlll, Epoch [4/15] loss = 1.084
Predicted:  ohlll, Epoch [5/15] loss = 1.002
Predicted:  ohlll, Epoch [6/15] loss = 0.932
Predicted:  ohlll, Epoch [7/15] loss = 0.865
Predicted:  ohlol, Epoch [8/15] loss = 0.800
Predicted:  ohlol, Epoch [9/15] loss = 0.740
Predicted:  ohlol, Epoch [10/15] loss = 0.693
Predicted:  ohlol, Epoch [11/15] loss = 0.662
Predicted:  ohlol, Epoch [12/15] loss = 0.641
Predicted:  ohlol, Epoch [13/15] loss = 0.625
Predicted:  ohlol, Epoch [14/15] loss = 0.611
Predicted:  ohlol, Epoch [15/15] loss = 0.599

嵌入层 Embedding

独热向量的缺点

  1. 维度太高（维度爆炸）
  2. 稀疏
  3. 硬编码（每个词对应每个向量，不是学习出来的）

那么能不能找到一个变换，把词的编码变成：

  • 低纬
  • 稠密
  • 从数据中学习

Embedding

将高维的、稀疏向量映射到低纬稠密的空间里。（也就是降维）
在这里插入图片描述
假设输入是4维的，嵌入层是5维，则需要构造如下的矩阵：
在这里插入图片描述
假设要查找的是2：从矩阵中输出对应那一行数据
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • torch.nn.Embedding：
    • num_embeddings：embbeding size，嵌入层的维度（）
    • embedding_dim：每一个输入数据的向量维度（比如说，x1~x5都是4维）

在这里插入图片描述
在这里插入图片描述

#练习5 Use Embedding
import torch
# parameters
num_class = 4
input_size = 4
hidden_size = 8
embedding_size = 10
num_layers = 2
batch_size = 1
seq_len = 5
idx2char = ['e', 'h', 'l', 'o']
x_data = [[1, 0, 2, 2, 3]]# (batch, seq_len)
y_data = [3, 1, 2, 3, 2] # (batch * seq_len)
inputs = torch.LongTensor(x_data)
labels = torch.LongTensor(y_data)
class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.emb = torch.nn.Embedding(input_size, 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),torch.zeros(num_layers, x.size(0), hidden_size))#The LSTM requires two hidden states
        hidden=torch.zeros(num_layers, x.size(0), hidden_size)
        x= self.emb(x) # (batch, seqLen, embeddingSize)
        x,states= self.rnn(x, hidden)#返回类型为tuble，切割tubel   by splitting up the tuple so that out is just your output tensor.
                                       #out then stores the hidden states, while states is another tuple that contains the last hidden and cell state.
        x = self.fc(x)
        return x.view(-1, num_class)

net = Model()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)
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()
    idx = outputs.argmax(dim=1)
    idx=idx.data.numpy()
    print('Predicted: ', ''.join([idx2char[x] for x in idx]), end='')
    print(', Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

结果：

Predicted: ooooo, Epoch [1/15] loss = 1.441
Predicted: ooooo, Epoch [2/15] loss = 1.148
Predicted: ooool, Epoch [3/15] loss = 1.007
Predicted: olool, Epoch [4/15] loss = 0.884
Predicted: olool, Epoch [5/15] loss = 0.760
Predicted: ohool, Epoch [6/15] loss = 0.609
Predicted: ohlol, Epoch [7/15] loss = 0.447
Predicted: ohlol, Epoch [8/15] loss = 0.313
Predicted: ohlol, Epoch [9/15] loss = 0.205
Predicted: ohlol, Epoch [10/15] loss = 0.135
Predicted: ohlol, Epoch [11/15] loss = 0.093
Predicted: ohlol, Epoch [12/15] loss = 0.066
Predicted: ohlol, Epoch [13/15] loss = 0.047
Predicted: ohlol, Epoch [14/15] loss = 0.033
Predicted: ohlol, Epoch [15/15] loss = 0.024

LSTM

  • 现在常用的memory管理方式叫做长短期记忆(Long Short-term Memory)，简称LSTM
  • LSTM对信息进行选择性的保留，是通过门控机制进行实现的。（即可以选择保留觉得有用的信息，遗忘觉得没用的信息。）
  • 冷知识：可以被理解为比较长的短期记忆，因此是short-term，而非是long-short term

在这里插入图片描述
在这里插入图片描述
官网文档

        self.rnn=torch.nn.LSTM(input_size=embedding_size,
                               hidden_size=hidden_size,
                               num_layers=num_layers,
                               batch_first=True)

LSMT学习能力比RNN强，但是时间复杂度高，训练时间长！

GRU(门控循环单元)

GRU 旨在解决标准 RNN 中出现的梯度消失问题。GRU 也可以被视为 LSTM 的变体，因为它们基础的理念都是相似的，且在某些情况能产生同样出色的结果。
GRU 背后的原理与 LSTM 非常相似，即用门控机制控制输入、记忆等信息而在当前时间步做出预测:

在这里插入图片描述

        self.rnn=torch.nn.GRAU(input_size=embedding_size,
                              hidden_size=hidden_size,
                              num_layers=num_layers,
                              batch_first=True)

练习

请用LSTM 和GRU完成训练。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Godot4.2】自定义简单的参数化2D网格节点

【Godot4.2】自定义简单的参数化2D网格节点

概述 在某些情况下我们可能需要在Godot中自定义2D网格&#xff0c;因为此时可能用TileMap会显得太“重”&#xff0c;因为我们可能只需要其作为网格的功能却不需要它的其他功能&#xff0c;比如绘制瓦片地图。而且我们可能需要在网格功能的基础上&#xff0c;添加更多自定义的…
阅读更多...
服务器版本命令查看

服务器版本命令查看

1、# uname &#xff0d;a &#xff08;Linux查看版本当前操作系统内核信息&#xff09; 2、# cat /proc/version &#xff08;Linux查看当前操作系统版本信息&#xff09; 3、# cat /etc/issue 或 cat /etc/redhat-release &#xff08;Linux查看版本当前操作系统发行版信息&…
阅读更多...
jmeter打开文件报异常无法打开

jmeter打开文件报异常无法打开

1、问题现象&#xff1a; 报错部分内容&#xff1a; java.desktop does not export sun.awt.shell to unnamed module 0x78047b92 [in thread "AWT-EventQueue-0"] 报错部分内容&#xff1a; kg.apc.jmeter.reporters.LoadosophiaUploaderGui java.lang.reflect.Invo…
阅读更多...
MPI4.1文档2：MPI术语与MPI操作过程

MPI4.1文档2：MPI术语与MPI操作过程

第2章 MPI术语与约定 MPI Terms and Conventions 这一章节解释了MPI文档中使用的符号术语和惯例&#xff0c;以及其中所做的一些选择和背后的原因。 2.1 文档符号表示 Document Notation Rational. 在整个文档中&#xff0c;对界面规范中所做设计选择的理由以这个格式(首尾包…
阅读更多...
Modbus TCP转Profinet网关如何实现Modbus主站与多设备通讯

Modbus TCP转Profinet网关如何实现Modbus主站与多设备通讯

在工业控制领域中&#xff0c;Modbus TCP转Profinet网关&#xff08;XD-ETHPN20&#xff09;扮演着连接不同设备间通讯的重要角色。当将Modbus主站与十几台服务器进行通讯时&#xff0c;通过modbus tcp转profinet网关&#xff08;XD-ETHPN20&#xff09;设备将不同协议间的数据…
阅读更多...
LabVIEW NV色心频率扫描

LabVIEW NV色心频率扫描

LabVIEW NV色心频率扫描 通过LabVIEW软件开发一个能够实现对金刚石氮空位&#xff08;Nitrogen-Vacancy&#xff0c;NV&#xff09;色心的频率扫描系统。系统通过USB协议与硬件设备通信&#xff0c;对NV色心进行高精度的频率扫描&#xff0c;满足了频率在2.6 GHz到3.2 GHz范围…
阅读更多...
python与excel第一节

python与excel第一节

python与excel第一节 由于excel在日常办公中大量使用&#xff0c;我们工作中常常会面对高频次或者大量数据的情况。使用python语言可以更加便捷的处理excel。 python与vba的比较 python语法更加简洁&#xff0c;相较于vba冗长复杂的语法&#xff0c;python更加容易学习。 p…
阅读更多...
阅读笔记（CVPR2020）Warping Residual Based Image Stitching for Large Parallax

阅读笔记（CVPR2020）Warping Residual Based Image Stitching for Large Parallax

基于变形残差的大视差图像拼接 K. -Y. Lee and J. -Y. Sim, "Warping Residual Based Image Stitching for Large Parallax," 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), Seattle, WA, USA, 2020, pp. 8195-8203, doi: 10.1109/…
阅读更多...
Grok-1：参数量最大的开源大语言模型

Grok-1：参数量最大的开源大语言模型

Grok-1&#xff1a;参数量最大的开源大语言模型 项目简介 由马斯克领衔的大型模型企业 xAI 正式公布了一项重要动作&#xff1a;开源了一个拥有 3140 亿参数的混合专家模型&#xff08;MoE&#xff09;「Grok-1」&#xff0c;连同其模型权重和网络架构一并公开。 此举将 Gro…
阅读更多...
行业模板｜DataEase制造行业大屏模板推荐

行业模板｜DataEase制造行业大屏模板推荐

DataEase开源数据可视化分析平台于2022年6月发布模板市场&#xff08;https://templates-de.fit2cloud.com&#xff09;&#xff0c;并于2024年1月新增适用于DataEase v2版本的模板分类。模板市场旨在为DataEase用户提供专业、美观、拿来即用的大屏模板&#xff0c;方便用户根据…
阅读更多...
智能合约语言（eDSL）—— 使用rust实现eDSL的原理

智能合约语言（eDSL）—— 使用rust实现eDSL的原理

为理解rust变成eDSL的实现原理&#xff0c;我们需要简单了解元编程与宏的概念,元编程被描述成一种计算机程序可以将代码看待成数据的能力&#xff0c;使用元编程技术编写的程序能够像普通程序在运行时更新、替换变量那样操作更新、替换代码。宏在 Rust 语言中是一种功能&#x…
阅读更多...
Nginx可视化管理实战攻略：提升管理效率新途径

Nginx可视化管理实战攻略：提升管理效率新途径

nginx-proxy-manager 是一个反向代理管理系统&#xff0c;它基于 Nginx&#xff0c;具有漂亮干净的 Web UI。还可以获得受信任的 SSL 证书&#xff0c;并通过单独的配置、自定义和入侵保护来管理多个代理。 特征 基于 Tabler(https://tabler.github.io/) 的美观安全的管理界面…
阅读更多...
代码学习记录23--回溯算法第四天

代码学习记录23--回溯算法第四天

随想录日记part23 t i m e &#xff1a; time&#xff1a; time&#xff1a; 2024.03.19 主要内容&#xff1a;回溯算法在代码学习中尤其重要&#xff0c;所以今天继续加深对其的理解&#xff1a;1&#xff1a;复原IP地址 &#xff1b;2.子集 &#xff1b;3.子集II 93.复原IP地…
阅读更多...
飞天使-k8s知识点26-kubernetes温故知新1-pod

飞天使-k8s知识点26-kubernetes温故知新1-pod

文章目录 创建一个podpod的启动命令和参数更改pod 镜像拉取策略 pod 的三种探针pod 探针的实现方式prestop 和 prestart 创建一个pod apiVersion: v1 # 必选&#xff0c;API 的版本号 kind: Pod # 必选&#xff0c;类型 Pod metadata: # 必选&#xff0c;元数据name: nginx # …
阅读更多...
学习总结1

学习总结1

算法 这两天对搜索(主要是dfs)进行了复习,写了四道题目. 解题思路 这道题我用dfs进行解题,这道题比起其他的只多了一个Z轴也就是多了两个方向. 代码 #include <string.h> #include <stdio.h> char g[31][31][31]; int ne[7][3]{{1,0,0},{-1,0,0},{0,1,0},{0,-1…
阅读更多...
Java 设计模式系列：行为型-状态模式

Java 设计模式系列：行为型-状态模式

简介 状态模式&#xff08;State Pattern&#xff09;是一种行为型设计模式&#xff0c;允许一个对象在其内部状态改变时改变其行为。状态模式中类的行为是由状态决定的&#xff0c;在不同的状态下有不同的行为。 状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂…
阅读更多...
[Halcon学习笔记]标定常用的Halcon标定板规格及说明

[Halcon学习笔记]标定常用的Halcon标定板规格及说明

1、介绍 大多数标定的要求都是以实心圆或方格来作为标志点&#xff0c;所以一般的标定板为棋盘格或矩阵圆点图&#xff0c;高精度的相机标定过程中&#xff0c;大多是以比较明确的特征点来作为参考&#xff0c;所以通过识别标定板的圆形&#xff0c;拟合出精确的中心位置&…
阅读更多...
力扣--最小覆盖子串--双端队列+滑动窗口

力扣--最小覆盖子串--双端队列+滑动窗口

滑动窗口思路&#xff08;双端队列实现&#xff09;&#xff1a; 可以参考一下&#xff1a;力扣hot8---滑动窗口-CSDN博客以及力扣hot9---滑动窗口-CSDN博客。 使用滑动窗口有以下几个步骤&#xff1a;初始化双端队列&#xff08;将s的前t_len个元素入队&#xff0c;此时检验是…
阅读更多...
1.IP复习课作业

1.IP复习课作业

1.IP复习课作业 1.为路由器各接口配置IP以及环回 R1 R2 R3 R4 R5 R6 2.配置dhcp为主机下发IP PC1 PC2 3.配置静态路由 R1 R2 R3 R4 R5 PC端通信 4.防止成环 R1 R2、4、5一样 5.修改优先级 R1 R2、3、4、5同样进行修改 6.均可访问R6环回 R5配置easy IP R1 ping R6环回 PC ping R…
阅读更多...
Mac版Jmeter安装与使用模拟分布式环境

Mac版Jmeter安装与使用模拟分布式环境

Mac版Jmeter安装与使用&模拟分布式环境 1 安装Jmeter 1.1 安装Java环境 国内镜像地址&#xff1a;https://repo.huaweicloud.com/java/jdk/11.0.29/jdk-11.0.2_osx-x64_bin.dmg 下载dmg后&#xff0c;双击进行安装。 配置环境变量&#xff1a; # 1 打开环境变量配置文件…
阅读更多...
最新文章

Copyright @ 2022~2023