循环神经网络-基础篇Basic-RNN

news2024/11/23 16:53:39

循环神经网络-基础篇Basic-RNN

我们把全连接网络也叫做稠密网络DNN,其中X1到X8是不同样本的特征

在这里插入图片描述

而本文介绍的循环神经网络RNN主要处理的是具有序列关系的输入数据,即前面的输入和后面的输入是有关系的。例如天气,股市,金融数据和自然语言等

什么是RNN

首先来看一个简单的循环神经网络结构

将序列 x 1 − x 4 x_{1}-x_{4} x1x4作为输入到 R N N C e l l RNN Cell RNNCell,它是一个线型层(Linear),可以得到隐层输出 h h h,其中 x 2 x_{2} x2不仅包含自己的信息,也包含 x 1 x_{1} x1的信息。

在这里插入图片描述

h 0 h_{0} h0是一个先验,例如,我们想要从图像到文本的转换时,我们可以选择用CNN+FC作为 h 0 h_{0} h0输入,结合RNN

如果我们没有先验,则把 h 0 h_{0} h0的维度设置和其余 h h h相同,其值为全0。

我们来具体看一下计算过程

  • 输入的维度是input_size*1
  • 隐层的维度是hidden_size
  • 线性变换 W i h x t + b i h W_{i h} x_{t}+b_{i h} Wihxt+bih,其中$ W KaTeX parse error: Undefined control sequence: \* at position 18: …是一个hidden\_size\̲*̲input\_size的矩阵。…W_{i h} x_{t}+b_{i h}$维度就和隐层的维度一致
  • 在上一层的权重矩阵 W h h W_{h h} Whh的维度是hidden_size * hidden_size
  • 我们把算出来的 W h h h t − 1 + b h h W_{h h} h_{t-1}+b_{h h} Whhht1+bhh W i h x t + b i h W_{i h} x_{t}+b_{i h} Wihxt+bih进行相加,都是hidden_size的向量
  • 融合完之后做一个 t a n h tanh tanh的激活函数
  • 最后算出来的 h t \boldsymbol{h}_{t} ht就是这一层的输出

在这里插入图片描述

其实本质上可以变成一个线型层

在这里插入图片描述

RNN构造

RNN构造在pytorch中有两种构造方式

  • 做自己的RNN Cell,自己写处理序列的循环
  • 直接使用RNN

第一种方式:RNN Cell

我们先来看一下RNN Cell是怎么用的

在设计RNN Cell 时,要确定输入维度input_size和输出维度hidden_size

在这里插入图片描述

在进行调用的时候要加上当前时刻的输入input加上当前的hidden

在这里插入图片描述

下面我们看一个实例

在这里插入图片描述

import torch

# Parameters
batch_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)

# (seq,batch,features)
dataset = torch.randn(seq_len,batch_size,input_size)
# Initializing the hidden to zero
hidden = torch.zeros(batch_size,hidden_size)

for idx,input in enumerate(dataset):
    print('=' * 20, idx, '='*20)
    print('Input size:', input.shape)  # the shape of input is (batchsize,inputsize)

    hidden = cell(input,hidden)

    print('hidden size:', hidden.shape)
    print(hidden)
    
 # ================输出结果===================
 ==================== 0 ====================
Input size: torch.Size([1, 4])
hidden size: torch.Size([1, 2])
tensor([[0.2663, 0.8438]], grad_fn=<TanhBackward0>)
==================== 1 ====================
Input size: torch.Size([1, 4])
hidden size: torch.Size([1, 2])
tensor([[-0.2387, -0.4385]], grad_fn=<TanhBackward0>)
==================== 2 ====================
Input size: torch.Size([1, 4])
hidden size: torch.Size([1, 2])
tensor([[0.8720, 0.5714]], grad_fn=<TanhBackward0>)

第二种方式:RNN

需要确定输入维度input_size和输出维度hidden_size和RNN的层数num_layers

其中inputs代表整个输入序列 x x xhidden代表 h 0 h_{0} h0,out代表隐层序列 h h hhidden代表最后的输出 h N h_{N} hN

在这里插入图片描述

我们需要确定他们的维度

在这里插入图片描述

下面我们看一个实例

在这里插入图片描述

📌什么是numLayers,例如下方有三个numLayers

在这里插入图片描述

import torch

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

cell = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers)

inputs = torch.randn(seq_len,batch_size,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)


 # ================输出结果===================
Output size: torch.Size([3, 1, 2])
Output: tensor([[[-0.1512,  0.2489]],

        [[-0.3888, -0.3375]],

        [[-0.1606,  0.4324]]], grad_fn=<StackBackward0>)
Hidden size: torch.Size([1, 1, 2])
Hidden tensor([[[-0.1606,  0.4324]]], grad_fn=<StackBackward0>)


另外还有一个参数是batch_first

在这里插入图片描述

序列到序列的例子

现在想要训练一个模型,把文本从hello 输出到 ohlol

在这里插入图片描述

这些文本字母并不是一个向量,我们第一步要把字母向量化表示

在这里插入图片描述

把输入的字母映射成一个词典,然后通过索引值,转化称为独热向量

最后的输出对应的也是长度为4的向量

在这里插入图片描述

下面就是整个进行训练的结构

在这里插入图片描述

使用RNN Cell代码演示

import torch

# ===============准备数据====================
input_size = 4
hidden_size = 4
batch_size = 1

# dictionary
idx2char = ['e', 'h', 'l', 'o']
x_data = [1, 0, 2, 2, 3]  # hello
y_data = [3, 1, 2, 3, 2]  # ohlol

# 独热向量
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]  # 维度是seq * input_size

# reshape the inputs to (seqLen,batchSize,inputSize)
inputs = torch.Tensor(x_one_hot).view(-1, batch_size, input_size)
# reshape the labels to (seqLen,1)
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__()
        # initial the parameters
        self.batch_size = batch_size
        self.input_size = input_size
        self.hidden_size = hidden_size
        # shape of inputs: (batchSize,inputSize)
        # shape of hidden: (batchSize,hiddenSize)
        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

    # 生成默认的h0
    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
    # 梯度归0
    optimizer.zero_grad()
    # h0
    hidden = net.init_hidden()
    print('Predicted string:',end='')
    # inputs 的维度是(seqLen,batchSize,inputSize) 按seqLen进行循环
    # input 的维度是(batchSize,inputSize)
    # labels 的维度是(seqSize,1)
    # label 的维度是(1)
    for input, label in zip(inputs,labels):
        hidden = net(input,hidden)
        loss += criterion(hidden, label) # 整个计算的loss和才是最终的loss
        # 把hidden中最大值的下标找到
        _, idx = hidden.max(dim=1)
        print(idx2char[idx.item()],end='')
    loss.backward()
    optimizer.step()
    print(', Epoch[%d/15] loss=%.4f' %(epoch+1, loss.item()))

输出结果

Predicted string:eoooe, Epoch[1/15] loss=7.5483
Predicted string:ooooo, Epoch[2/15] loss=6.0676
Predicted string:ooool, Epoch[3/15] loss=5.2073
Predicted string:ohlol, Epoch[4/15] loss=4.7479
Predicted string:ohlol, Epoch[5/15] loss=4.4771
Predicted string:ohlol, Epoch[6/15] loss=4.2829
Predicted string:ohlol, Epoch[7/15] loss=4.0976
Predicted string:ohlol, Epoch[8/15] loss=3.8791
Predicted string:ohlol, Epoch[9/15] loss=3.6212
Predicted string:ohlol, Epoch[10/15] loss=3.3628
Predicted string:ohlol, Epoch[11/15] loss=3.1412
Predicted string:ohlol, Epoch[12/15] loss=2.9649
Predicted string:ohlol, Epoch[13/15] loss=2.8203
Predicted string:ohlol, Epoch[14/15] loss=2.6825
Predicted string:ohlol, Epoch[15/15] loss=2.5410

使用RNN代码演示

import torch

# ===============准备数据====================
input_size = 4
hidden_size = 4
batch_size = 1
num_layers = 1
seq_len = 5

# dictionary
idx2char = ['e', 'h', 'l', 'o']
x_data = [1, 0, 2, 2, 3]  # hello
y_data = [3, 1, 2, 3, 2]  # ohlol

# 独热向量
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]  # 维度是seq * input_size

# reshape the inputs to (seqLen,batchSize,inputSize)
inputs = torch.Tensor(x_one_hot).view(seq_len, batch_size, input_size)
# reshape the labels to (seqLen*batchSize,1)
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__()
        # initial the parameters
        self.num_layers = num_layers
        self.batch_size = batch_size
        self.input_size = input_size
        self.hidden_size = hidden_size
        # shape of inputs: (batchSize,inputSize)
        # shape of hidden: (batchSize,hiddenSize)
        self.rnn = torch.nn.RNN(input_size=self.input_size,hidden_size=self.hidden_size,num_layers=self.num_layers)

    def forward(self, input):
        # shape of hidden:(numLayers,batchSize,hiddenSize)
        hidden = torch.zeros(self.num_layers,self.batch_size,self.hidden_size)
        out,_ =self.rnn(input,hidden)
        # reshape out to: (seqLen*batchSize,hiddenSize)
        return out.view(-1,self.hidden_size)

    # 生成默认的h0
    def init_hidden(self):
        return torch.zeros(self.batch_size, self.hidden_size)


net = Model(input_size, hidden_size, batch_size,num_layers)


# ===============损失和优化器====================
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(),lr=0.1)

# ===============训练模型====================
# inputs 的维度是(seqLen,batchSize,inputSize) 按seqLen进行循环
# input 的维度是(batchSize,inputSize)
# labels 的维度是(seqSize,1)
# label 的维度是(1)
for epoch in range(15):
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs,labels)
    loss.backward()
    optimizer.step()
    # 把hidden中最大值的下标找到
    _, idx = outputs.max(dim=1)
    idx = idx.data.numpy()
    print('Predicted;',''.join([idx2char[x] for x in idx]), end='')
    print(', Epoch[%d/15] loss=%.4f' %(epoch+1, loss.item()))

输出结果

Predicted; lllll, Epoch[1/15] loss=1.3361
Predicted; lllll, Epoch[2/15] loss=1.1672
Predicted; ohlll, Epoch[3/15] loss=1.0181
Predicted; ohlll, Epoch[4/15] loss=0.8844
Predicted; ohlol, Epoch[5/15] loss=0.7967
Predicted; ohloo, Epoch[6/15] loss=0.7348
Predicted; ohloo, Epoch[7/15] loss=0.6838
Predicted; ohloo, Epoch[8/15] loss=0.6443
Predicted; ohloo, Epoch[9/15] loss=0.6131
Predicted; ohlol, Epoch[10/15] loss=0.5868
Predicted; ohlol, Epoch[11/15] loss=0.5629
Predicted; ohlol, Epoch[12/15] loss=0.5373
Predicted; ohlol, Epoch[13/15] loss=0.5034
Predicted; ohlol, Epoch[14/15] loss=0.4587
Predicted; ohlol, Epoch[15/15] loss=0.4225

embedding嵌入层

独热编码的缺点

  • 高纬度
  • 向量稀疏
  • 硬编码

由此引出了Embedding嵌入层,把高维的稀疏的样本映射到稀疏的稠密的空间里

在这里插入图片描述

接下来看一下数据降维的方式

embedding的原理是使用矩阵乘法来进行降维,从而达到节约存储空间的目的。

假设 i n p u t S i z e inputSize inputSize是4维的, e m b e d d i n g S i z e embeddingSize embeddingSize是5维的,我们想要4维转换成5维,就构建一个矩阵

在这里插入图片描述

在这个矩阵中我们可以做出查询,比如查询索引为2,Embedding Layer就把一整行的向量输出

在这里插入图片描述

https://blog.csdn.net/qq_36722887/article/details/118613262

https://blog.csdn.net/qq_41775769/article/details/121825668?ops_request_misc=&request_id=&biz_id=102&utm_term=Embedding&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-121825668.nonecase&spm=1018.2226.3001.4187


下面我们使用embedding嵌入层和linear layer线型层来优化RNN

在这里插入图片描述

embedding参数中,有以下的内容

在这里插入图片描述

前两个参数是指输入的维度和embedding维度,构成了矩阵的维度

在这里插入图片描述

输入是(seg*batch)的向量,输出就是((seg*batch)embedding_dim)

线型层参数如下

在这里插入图片描述

交叉熵参数

在这里插入图片描述

网络结构如下

在这里插入图片描述

在这个例子中我们使用了batch_first=True

在这里插入图片描述

全连接层中

在这里插入图片描述

最后把输出变成矩阵形式

在这里插入图片描述

代码演示

import torch

# ===============准备数据====================
num_class = 4  # 类别
input_size = 4  # 输入
hidden_size = 8  # 输出
embedding_size = 10  # 嵌入层
num_layers = 2  # 2层RNN
batch_size = 1
seq_len = 5  # 序列长度

# dictionary
idx2char = ['e', 'h', 'l', 'o']
x_data = [[1, 0, 2, 2, 3]]  # hello  (batch,seqLen)
y_data = [3, 1, 2, 3, 2]  # ohlol  (batch*seqLen)
inputs = torch.LongTensor(x_data)
labels = torch.LongTensor(y_data)


# ===============构造模型====================
class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        # matrix of Embedding: (inputSize,embeddingSize)
        self.emb = torch.nn.Embedding(input_size, embedding_size)
        # batch_First=True   input of RNN:(batch,seqLen,embeddingSize)   output of RNN:(batchSize,seqLen,hiddenSize)
        self.rnn = torch.nn.RNN(input_size=embedding_size, hidden_size=hidden_size, num_layers=num_layers,
                                batch_first=True)
        # input of FC layer:(batchSize,seqLen,hiddenSize)  output of FC layer:(batchSize,seqLen,numClass)
        self.fc = torch.nn.Linear(hidden_size, num_class)

    def forward(self, x):
        hidden = torch.zeros(num_layers, x.size(0), hidden_size)
        # input should be LongTensor:(batchSize,seqLen)
        x = self.emb(x)  # output of shape :(batch,seqLen,embeddingSize)
        x, _ = self.rnn(x, hidden)
        x = self.fc(x)
        # reshape result to use Cross Entropy Loss: (batchSize*seqLen,numClass)
        return x.view(-1, num_class)

    # 生成默认的h0
    def init_hidden(self):
        return torch.zeros(self.batch_size, self.hidden_size)


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()
    # 把hidden中最大值的下标找到
    _, idx = outputs.max(dim=1)
    idx = idx.data.numpy()
    print('Predicted;', ''.join([idx2char[x] for x in idx]), end='')
    print(', Epoch[%d/15] loss=%.4f' % (epoch + 1, loss.item()))

输出结果

Predicted; lleel, Epoch[1/15] loss=1.4850
Predicted; lllll, Epoch[2/15] loss=1.1580
Predicted; lllll, Epoch[3/15] loss=0.9671
Predicted; lhlll, Epoch[4/15] loss=0.7869
Predicted; ohlol, Epoch[5/15] loss=0.6619
Predicted; ohlol, Epoch[6/15] loss=0.5250
Predicted; ohlol, Epoch[7/15] loss=0.4078
Predicted; ohlol, Epoch[8/15] loss=0.3297
Predicted; ohlol, Epoch[9/15] loss=0.2575
Predicted; ohlol, Epoch[10/15] loss=0.2005
Predicted; ohlol, Epoch[11/15] loss=0.1565
Predicted; ohlol, Epoch[12/15] loss=0.1194
Predicted; ohlol, Epoch[13/15] loss=0.0863
Predicted; ohlol, Epoch[14/15] loss=0.0588
Predicted; ohlol, Epoch[15/15] loss=0.0423

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

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

相关文章

iText如何提取PDF中的数据——1. 总览

作者&#xff1a;CuteXiaoKe 微信公众号&#xff1a;CuteXiaoKe | 原文 最近收到大家很多的私信提问&#xff0c;也是大家比较关心的问题:如果我有一个PDF&#xff0c;我该如何使用iText获取PDF里面的内容呢&#xff0c;比如文本、图片、表格等。iText官方给出了相关的整体解决…

基于Xlinx的时序分析与约束(5)----衍生时钟约束

衍生时钟约束语法 衍生时钟&#xff08;Generated Clocks&#xff0c;又称为生成时钟&#xff09;是指由设计中已有的主时钟通过倍频、分频或者相移等操作后产生的新的时钟信号&#xff0c;如由MMCM或PLL或由组合逻辑生成的倍、分频时钟信号。 衍生时钟约束必须指定时钟源&…

【高级篇04】MySQL逻辑架构

文章目录第四章&#xff1a;逻辑架构逻辑架构SQL执行流程数据库缓冲池第四章&#xff1a;逻辑架构 逻辑架构 第一层&#xff1a;连接层。客户端访问MySQL服务器&#xff0c;首先建立TCP连接&#xff0c;经过三次握手建立连接成功后&#xff0c;MySQL服务器对TCP传输过来的账号…

各个集合比较

1、 Queue与Deque的区别 引言&#xff1a; 在研究java集合源码的时候&#xff0c;发现了一个很少用但是很有趣的点&#xff1a;Queue以及Deque&#xff1b; 平常在写leetcode经常用LinkedList向上转型Deque作为栈或者队列使用&#xff0c;但是一直都不知道Queue的作用&#x…

微信小程序入门

目录 一&#xff0c;简介 二&#xff0c;小程序开发环境搭建 1.申请账号 2.安装开发工具 3.小程序工具使用 三&#xff0c;目录结构以及json配置 1.目录结果 2.json配置 3.JSON 语法 4.WXML 5.wxss 6.JS 逻辑交互 四&#xff0c;小程序宿主环境 1.程序与页面 2.组件…

DFMEA之严重度/频度/探测度/风险优先系数

文章目录介绍严重度频度探测度风险优先系数介绍 在实施DFMEA阶段中&#xff0c;要求、潜在失效模式、潜在失效后果、潜在失效原因和现有设计控制措施等 5 个为基础项, 它们的分析是决定 DFMEA实施成功与否的关键&#xff1b;严重度&#xff08;S&#xff09;&#xff0c;频度&a…

4.2、网络层提供的两种服务

1、面向连接的虚电路服务 虚电路服务的核心思想&#xff1a;可靠通信由网络自身来保证\color{red}可靠通信由网络自身来保证可靠通信由网络自身来保证 当两台计算机进行通信时&#xff0c;必须建立网络层的连接\color{red}网络层的连接网络层的连接----虚电路VC\color{red}虚…

centos7搭建DNS服务(use)

参考&#xff1a;centos7搭建DNS服务完整版 CentOS 7 配置DNS服务 Centos7 DNS 服务器配置步骤 --use DNS服务类型 主机记录记录类型记录值ns1A192.168.1.1ns2A192.168.1.2wwwA192.168.1.100bbsCNAMEwwwftpA192.168.1.110mailMX 10192.168.1.120 一、服务配置 1.1 关闭SELi…

模型实战一之YOLOv7实例分割、模型训练自己数据集

模型实战一之YOLOv7实例分割、模型训练自己数据集 1.环境准备 下载yolov7实例分割模型&#xff1a; git clone https://github.com/WongKinYiu/yolov7.git -b mask yolov7-maskcd yolov7-mask安装环境 #查看已安装环境 conda info --envs #查看安装了哪些包 conda list#创建…

IMX6ULL学习笔记(15)——GPIO输出接口使用【官方SDK方式】

一、GPIO简介 i.MX6ULL 芯片的 GPIO 被分成 5 组,并且每组 GPIO 的数量不尽相同&#xff0c;例如 GPIO1 拥有 32 个引脚&#xff0c; GPIO2 拥有 22 个引脚&#xff0c; 其他 GPIO 分组的数量以及每个 GPIO 的功能请参考 《i.MX 6UltraLite Applications Processor Reference M…

市级数字政府电子政务大数据中心项目建设和运营方案

【版权声明】本资料来源网络&#xff0c;仅用于行业知识分享&#xff0c;供个人学习参考&#xff0c;不得作商业用途。【侵删致歉】如有侵权请联系小编&#xff0c;将在收到信息后第一时间进行删除&#xff01; 完整资料领取见文末&#xff0c;部分资料内容&#xff1a; 1.1 大…

【QTimeEdit | QDateEdit | QDateTimeEdit | QCalendarWidget | QLCDNumber】

【QTimeEdit | QDateEdit | QDateTimeEdit | QCalendarWidget | QLCDNumber】【1】UI界面设计【2】相关头文件【3】构造函数初始化【4】setDate | setTime | setDateTime | currentDate | currentTime | currentDateTime【5】maximumDate | maximumTime | minimumDate | minimu…

基于Java+SpringBoot+vue等疫情期间网课管理系统详细设计和实现

博主介绍&#xff1a;✌全网粉丝20W,csdn特邀作者、博客专家、CSDN新星计划导师、java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取联系&#x1f345;精彩专栏推荐订阅收藏&#x1f447;&…

使用Prometheus和Grafana监控Apache Doris

目录1. 介绍2. Prometheus和Grafana的简单使用3. 配置Prometheus的prometheus.yml4. 下载Doris Dashboard模板1. 介绍 Doris的FE和BE通过http端口metrics路径&#xff0c;将监控数据暴露出来&#xff0c;以key-value的文本形式对外展现&#xff0c;每个key还可能有不同的Label…

Nacos注册中心

【Spring Cloud Alibaba】 1. Spring Cloud Alibaba Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件&#xff0c;方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。 依托 Spring Cloud …

微信小程序开发—入门到跑路(五)

文章目录1. 今日目标2. 使用 npm2.1 小程序对 npm 的支持和限制问题2.2 了解什么是 vant Weapp2.3 安装 Vant 组件库问题2.4 使用 Vant 组件问题2.5 定义和使用 CSS 变量问题2.6 使用 CSS 变量定制 Vant 的主题样式问题2.7 什么是小程序 API 的 Promise 化2.8 安装并构建 minip…

运输层协议概述(计算机网络-运输层)

目录 运输层协议的位置 运输层为相互通信的应用进程提供了逻辑通信 应用进程之间的通信 客户-服务器通信模式 互联网的运输层协议 UDP 与 TCP 运输层的复用与分用 运输层端口的概念 端口在进程之间的通信中所起的作用 端口号 运输层协议的位置 从通信和信息处理的角度…

2022年终总结(脚踏实地,仰望星空)

2022年终总结 回忆录 2022年焦虑和快乐是这一年中最大的两种情绪了。焦虑主要是因为心里的三块石头&#xff0c;从年初就开始悬着。第一块石头&#xff0c;科研论文录用&#xff0c;第二个石头&#xff0c;拿到国奖&#xff0c;第三个石头是拿到满意的offer。目前只剩下最后一…

网络实验之EtherChannel技术实践

一、EtherChannel简介 EtherChannel简单来说就是将多个物理端口绑定为一个逻辑端口&#xff0c;通过多个端口绑定&#xff0c;能充分利用现有端口来增加带宽。构成etherchannel的端口必须配置成相同的特性&#xff0c;如双工模式、速度、同为FE或GE端口、native VLAN,、VLAN ra…

C++11标准模板(STL)- 算法(std::inner_product)

定义于头文件 <algorithm> 算法库提供大量用途的函数&#xff08;例如查找、排序、计数、操作&#xff09;&#xff0c;它们在元素范围上操作。注意范围定义为 [first, last) &#xff0c;其中 last 指代要查询或修改的最后元素的后一个元素。 计算两个范围的元素的内积…