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 torchbatch_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作为下一个的hiddenprint('output size:',hidden.shape) #[1, 2],output size=hidden size,上一个的output作为下一个的hiddenprint(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 torchbatch_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_sizeself.input_size=input_sizeself.hidden_size=hidden_sizeself.rnncell=torch.nn.RNNCell(input_size=input_size,#(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)hidden_size=hidden_size)#(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒉𝒊𝒅𝒅𝒆𝒏𝑺𝒊𝒛𝒆)def forward(self, input,hidden):hidden=self.rnncell(input,hidden)return hiddendef 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=0optimizer.zero_grad()#梯度清零hidden=net.init_hidden()print("Predicted string:",end='')# input:(𝒔𝒆𝒒𝑳𝒆𝒏,𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)->input:(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆,𝒊𝒏𝒑𝒖𝒕𝑺𝒊𝒛𝒆)for input,label in zip(inputs,labels):hidden=net(input,hidden)#RNNcellloss+=criterion(hidden,label)_,idx=hidden.max(dim=1)print(idx2char[idx.item()],end='')loss.backward()#backwardoptimizer.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_sizeself.hidden_size=hidden_sizeself.batch_size=batch_sizeself.num_layers=num_layersself.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 stepoptimizer.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 stateshidden=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完成训练。

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

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

相关文章

游泳耳机哪个牌子好?强烈推荐这4大高性能款式!

在如今的科技时代&#xff0c;游泳耳机已经成为了许多游泳爱好者和运动员的必备装备。一款好的游泳耳机不仅可以让你在水中享受到美妙的音乐&#xff0c;还可以为你提供更好的训练体验。 &#xff08;下图是我测试过的一部分游泳耳机&#xff1a;&#xff09; 但在市场上众多的…

基于FPGA实现的UDP协议栈设计_汇总

基于FPGA实现的千兆以太网UDP协议栈设计&#xff08;汇总篇&#xff09; 1. MAC设计 2. IP层设计 3. ARP层设计 4. UDP层设计 5. ICMP层设计 6. 仲裁器设计 8. RGMII接口设计 9. 跨时钟域设计

公募基金公开市场数据基础分析实例

公募基金公开市场数据基础分析 公募基金公开市场数据基础分析示例代码1.1 公开市场数据表结构 字段 字段类型 含义 SecurityID SYMBOL 基金代码 FullName STRING 基金全称 Name STRING 基金简称 Management SYMBOL 基金公司 Type SYMBOL 基金类型 Custodian SYMBOL 托管人 Issu…

AI大模型在医疗领域的应用案例:自然语言处理与医疗文本分析

随着人工智能技术的快速发展&#xff0c;AI大模型在自然语言处理、图像识别、语音识别等领域的应用越来越广泛。在医疗领域&#xff0c;AI大模型的应用正在深刻改变着医疗实践&#xff0c;为患者和医生带来前所未有的便利。近期AI医疗的概念也比较火热&#xff0c;本文将聚焦于…

编程题:相同数字的积木游戏(Java)

题目描述 小华和小薇一起通过玩积木游戏学习数学。 他们有很多积木&#xff0c;每个积木块上都有一个数字&#xff0c;积木块上的数字可能相同。 小华随机拿一些积木挨着排成一排&#xff0c;请小薇找到这排积木中数字相同目所处位置最远的2块积木块&#xff0c;计算他们的…

css的border详解

CSS的border属性是一个简写属性&#xff0c;用于设置以下四个边框属性&#xff1a; border-width&#xff1a;定义边框的宽度。可以使用具体的像素值&#xff0c;或者使用预定义的关键字如thin、medium和thick。border-width不支持百分比值。默认情况下&#xff0c;边框的宽度是…

在线文本列表差集计算器

具体请前往&#xff1a;在线文本差集计算工具

system Verilog:clocking中定义信号为input和output的区别

在SystemVerilog中&#xff0c;clocking块用于定义时钟块&#xff0c;这通常用于描述时钟边缘和同步的输入/输出行为&#xff0c;特别是在测试平台和硬件接口描述中。 在下述两个代码示例中&#xff0c;主要区别在于a被定义为一个input还是output。 当a被定义为input时&#x…

云计算 3月22号 (mysql的主从复制)

一、MySQL-Replication&#xff08;主从复制&#xff09; 1.1、MySQL Replication 主从复制&#xff08;也称 AB 复制&#xff09;允许将来自一个MySQL数据库服务器&#xff08;主服务器&#xff09;的数据复制到一个或多个MySQL数据库服务器&#xff08;从服务器&#xff09;…

优化选址问题 | 基于禁忌搜索算法求解基站选址问题含Matlab源码

目录 问题代码问题 禁忌搜索算法(Tabu Search)是一种局部搜索算法的扩展,它通过引入一个禁忌列表来避免陷入局部最优解,并允许在一定程度上接受较差的解来跳出局部最优。在基站选址问题中,我们可以使用禁忌搜索算法来寻找满足覆盖要求且基站数量最少的选址方案。 以下是…

Allegro许可管理技巧

在数字化时代&#xff0c;软件许可管理对于企业的运营至关重要。然而&#xff0c;许多企业在实施软件管理过程中会遇到各种问题。Allegro许可管理作为一款高效、合规的管理工具&#xff0c;能够帮助企业解决常见的许可管理问题。本文将深入探讨Allegro许可管理中的实用技巧&…

活用C语言之宏定义应用大全

零、C语言宏定义知多少 C语言的编程过程中经常会用到宏定义,然而如果你只是使用宏定义做一些常量的定义,那么你不是OUT了就是C语言小白。 那么我们在编程过程中,宏定义都有哪些作用呢? 常量定义 可以作为功能代码的开关 防止头文件被重复包含 定义一些通用类型,防止因为…

比赛记录:Codeforces Round 936 (Div. 2) A~E

传送门:CF [前题提要]:赛时一小时过了A~D,E感觉也不是很难(甚至感觉思维难度是小于D的),感觉这回是自己不够自信了,要是自信一点深入想一下应该也能做出来,咱就是说,如果E和D换一下,结果也是一样的,虽上大分,但是心里很不服,故记录一下 A - Median of an Array 当时网卡加载了…

手机网页视频批量提取工具可导出视频分享链接|爬虫采集下载软件

解放你的抖音视频管理——全新抖音批量下载工具震撼上线&#xff01; 在这个信息爆炸的时代&#xff0c;如何高效地获取、管理和分享视频内容成为了许多用户的迫切需求。为了解决这一难题&#xff0c;我们研发了全新的视频批量下载工具&#xff0c;让你轻松畅享海量音视频资源。…

SQL中条件放在on后与where后的区别

数据库在通过连接两张或多张表来返回记录时&#xff0c;都会生成一张中间的临时表&#xff0c;然后再将这张临时表返回给用户。 在使用left jion时&#xff0c;on和where条件的区别如下&#xff1a; on条件是在生成临时表时使用的条件&#xff0c;不管on中的条件是否为真&…

2024年 前端JavaScript Web APIs 第四天 笔记

4.1-日期对象的使用 4.2-时间戳的使用 4.3-倒计时案例的制作 4.4-查找DOM节点 4.5-增加节点以及学成在线案例 4.6-克隆节点和删除节点 4.7-M端事件 4.8-swiper插件的使用 4.9-今日综合案例-学生信息表 B站 <!DOCTYPE html> <html lang"en"><head>&…

ubuntu下samba匿名读写服务器

目的&#xff1a; 局域网内&#xff0c;ubuntu下&#xff0c;创建SAMBA文件共享服务器。匿名读写权限。为了开发项目组文件共享传输方便。 环境&#xff1a; X86_64电脑一台。 操作系统&#xff1a; Ubuntu 20.04 LTS 64位。 安装samba $ sudo apt-get install samba创建…

浅谈智能微型断路器在学校改造项目中的应用-安科瑞 蒋静

南浜路初中是昆山市重点建设的教育民生项目。当地政府对于这所学校非常重视&#xff0c;当然也有着很高的期望。南浜路初中的到来能够进一步促进昆山市义务教育阶段的发展&#xff0c;提升义务教育水平。 现场图片 智能网关 可连接至多16台智能微型断路器&#xff1b;可查看各…

UNI-APP读取本地JSON数据

首先要把json文件放在static文件夹下 然后在要读取数据的页面导入 import data from ../../static/data.json读取数据&#xff1a; onLoad() {console.log(data, data)}, 打印出来的就是JSON文件里的数据了

时序预测 | Matlab基于BiTCN-LSTM双向时间卷积长短期记忆神经网络时间序列预测

时序预测 | Matlab基于BiTCN-LSTM双向时间卷积长短期记忆神经网络时间序列预测 目录 时序预测 | Matlab基于BiTCN-LSTM双向时间卷积长短期记忆神经网络时间序列预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 1.Matlab基于BiTCN-LSTM双向时间卷积长短期记忆神经网络时…