深度学习 | DRNN、BRNN、LSTM、GRU


 1、深度循环神经网络

1.1、基本思想

        能捕捉数据中更复杂模式并更好地处理长期依赖关系。

        深度分层模型比浅层模型更有效率。

        Deep RNN比传统RNN表征能力更强。

        那么该如何引入深层结构呢?

传统的RNN在每个时间步的迭代都可以分为三个部分:

1.2、三种深层方式

        

        在传统RNN中,这三处都没有中间层,变换函数都是线性变换紧跟着一个非线性函数,也就是所谓的浅层变换。

        所以就有三种思路,来看看各个思路的变体:

DT-RNN

        这样的好处就是它允许隐变量 ht 适应输入模式 xt 的快速变换,而且它保留了对过去训练的提炼和总结。

        既能适应新变换又不忘初心。这种高度非线性转换可以通过若干个 MLP 全连接层(多层感知机)来实现。

        

DT(S) - RNN

        由于DT-RNN增加了Loss的梯度,沿着时间反向传播时需要遍历更多的非线性的步数。

        

DOT-RNN

        

        

Stacked RNN

                

模型比较

        

        DT-RNN 和 Stacked  RNN 是正交的:

        堆叠的RNN可以出来输入序列中多个时间尺度,而DT-RNN做不到,但是如果将多个DT-RNN堆叠起来,他就可以同时拥有DT-RNN和Stacked RNN 的能力了。

小结

        在传统RNN的基础上,增加多个浅变换结构的隐藏层,实现对复杂特征更有效的捕捉和处理。

        


 2、双向循环神经网络

2.1、单向RNN的局限

        多数RNN只有一个因果结构;

        许多应用中,输出预测可能依赖整个输入序列;

        往往需要捕捉序列中上下文之间的关系;

2.2、双向网络结构 —— 两个互相叠加的RNN

       

        输入不仅取决于先前,还取决于未来。

        

        六个权重矩阵。

        

 2.3、训练过程

        两遍运算,输入翻转。

         

2.4、主要特点分析

        使用来自序列两端的信息来估计输出;

        前向传播需要在双向层中进行,反向传播依赖前向传播结果;

        计算速度慢,梯度求解链很长,训练代价高;

        主要用于序列编码和双向上下文观测统计。


 3、长短期记忆网络 LSTM

         Long-Short Term Memory

 3.1、RNN的问题

        处理长序列数据时会有梯度消失或爆炸的问题(权重矩阵连乘)

        RNN的计算效率相对较低。

        

        长时间以前的记忆基本对现在没有什么影响了。

        

        

3.2、基本思想

        保留较长序列数据中重要信息,忽略不重要信息。

        

        RNN都有重复链式结构;

        标准RNN结构简单;

        LSTM链式结构特殊;

        

3.3、门控记忆单元

        门(gate)控制记忆单元,信息可以沿着这个链条传送。

        原来的RNN隐藏层中只有一个状态 h ,它对短期输入是很敏感的。

        现在人为添加状态 c ,来保持长期记忆。

        打个比方来讲,底下的短期链条相当于时刻发生的事情,上面的链条相当于日记本,记录了长期的记忆 Cells statement 。

        那该怎么控制这种长期的状态 c 呢?

        在任意的时刻 t ,我们需要三件事情:

                t-1 时刻传入的状态 c t-1 中要决定有多少信息需要保留;

                当前时刻的输入信息有多少需要传递到 t+1 时刻;

                当前时刻的隐层输出 ht 是什么。

        ———— LSTM专门设计了 GRU门控记忆单元 来控制信息的保留和丢弃。具体来说包括了三种门。每个门就是选择信息通过的方式。

        

        先来介绍下他们的基本工作原理,之所以称之为门,一定要有一个控制信号,每个门是由一个sigmoid神经网络层以及逐点乘法运算组成的。

        三个门的作用可以分别理解为:橡皮擦(擦除一些没有用的记忆)、铅笔(写上一些新的记忆)、再输出。

        1、遗忘门(forget gate)

                决定去除那些信息。过滤重要的信息,忽略无关的信息。

                h t-1:上一时刻记忆的状态;

                x t:当前时间步输入的信息;

                这两个的加权和经过一个sigmiod函数,产生遗忘门的输出 f t ,再作用到 c t-1。

                因为 f t 是一个0到1之间的数(橡皮擦),相当于对 c t-1 里面的信息进行了一些选择。

                

        2、输入门 (input gate)

                决定什么新的信息将被保留下来。

                在日记本上增加那些记录。

                        sigmiod层决定我们将更新哪些值;

                        tanh 层 创建一个新的候选值向量。

                

        输入门和候选记忆单元联合更新状态。

        用橡皮在日记本上删减,再用铅笔添加记录。最后得到了新的长期记忆 c t 。

                

         

        3、输出门(output gate)

                控制记忆细胞更新时所使用的输入信息。

                日记更新当前短期记忆。

                 控制长期记忆更新并输出给短期记忆 h t 。

                 先运行一个 sigmoid 层决定要输出 cell 状态的哪些部分 o t (告诉长期记忆哪些部分要去输出);

                 将cell状态 o t 加上tanh函数之后得到输出 h t 。 tanh函数将c t 值推到 -1 到 1之间。

               


 4、门控循环单元 GRU

         Gated Recurrent Unit

        2014年提出,主要针对LSTM模型计算比较复杂容易出现梯度消失或爆炸等问题进行改进。

4.1、与LSTM的区别

        1、将LSTM原来的三个门简化成为两个:重置门和更新门

        2、不保留单元状态,只保留隐藏状态作为单元输出

        3、重置门直接作用于前一时刻的隐藏状态

        

4.2、基本原理

        引入了两种“门”来控制信息的流动,即重置门(reset gate) 和更新门 (update gate)。

        这两种门都是由一个神经元组成的,通过对输入和上一时刻隐藏状态进行计算来得到当前时刻的输出。

        

4.2.1、重置门(Reset Gate)

        用来决定从上一时刻的隐藏状态中“复制”多少信息。

        重置门的输出值在0到1之间,表示从上一时刻的隐藏状态中复制的信息量。

        

4.2.2、更新门 (Update Gate)

        用来决定从上一时刻的隐藏状态中“更新”多少信息。

        

4.2.3、候选隐状态

        候选隐状态是用来计算当前时刻隐藏状态的一个中间结果,将当前时刻的输入与上一时刻隐藏状态结合起来从而得到当前时刻隐藏状态输出 h t 。

        由当前时刻的输入 x t 和上一时刻的隐藏状态 h t-1 通过权重矩阵和偏置向量计算向量得到,并且通过 tanh 函数得到。

        中间小圆圈表示的是元素级别的乘法运算,不同于矩阵乘法。

        

        在计算当前时刻的隐藏状态 h t 时,会与更新门的输出 z t 一起计算,

        当 z t 比较大时,隐藏状态会更多的使用候选隐状态;反之则使用上一时刻的隐藏状态 h t-1;

4.2.4、隐状态

         模型在处理序列数据时记录的当前时刻之前的信息。

         隐状态在计算中主要有两个作用,

                1、记录序列数据的上下文信息,帮助模型更好的处理序列数据。

                2、控制信息流动,来解决梯度消失和梯度爆炸的问题,提高模型效率。

        

4.3、计算步骤

        1、计算重置门输出 rt

        2、计算更新门输出 zt

        3、计算候选隐状态 (注意私用tanh 和元素级相乘)

        4、计算最终隐藏层输出 ht

        


5、复杂RNN代码实现

        DRNN-更深的网络结构

        BRNN-双向的训练方向

        LSTM-更强的记忆能力

        GRU-更简洁而高效

5.1. 模型定义

1.1 深度循环神经网络

rnn模型默认激活函数是tanh,会得到loss太大了,模型几乎无法拟合样本,这是由于

数据集中 收盘价 Close 非常大,这样会导致rnn模型很容易出现 梯度消失和梯度爆炸。

我们可以通过修改激活函数来解决,初始化 加入 nonlinearity = 'relu'。

或者可以对数据进行归一化。若结果依旧不好,可能是因为学习率设置过大,一开始是0.1。但是如果出现没有拟合,是因为不能拟合原始数据了,要拟合归一化后的x。

from torch import nn
from tqdm import *class DRNN(nn.Module):def __init__(self, input_size, output_size, hidden_size, num_layers):super(DRNN, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True) # batch_first 为 True时output的tensor为(batch,seq,feature),否则为(seq,batch,feature)self.linear = nn.Linear(hidden_size, output_size)def forward(self, x):# 初始化隐藏状态和细胞状态state = torch.zeros(self.num_layers, x.size(0), self.hidden_size)# 计算输出和最终隐藏状态output, _ = self.rnn(x, state)output = self.linear(output)return output
# 网络结构
model = DRNN(16, 16, 64, 2)
for name,parameters in model.named_parameters():print(name,':',parameters.size())
rnn.weight_ih_l0 : torch.Size([64, 16])
rnn.weight_hh_l0 : torch.Size([64, 64])
rnn.bias_ih_l0 : torch.Size([64])
rnn.bias_hh_l0 : torch.Size([64])
rnn.weight_ih_l1 : torch.Size([64, 64])
rnn.weight_hh_l1 : torch.Size([64, 64])
rnn.bias_ih_l1 : torch.Size([64])
rnn.bias_hh_l1 : torch.Size([64])
linear.weight : torch.Size([16, 64])
linear.bias : torch.Size([16])

1.2 双向循环神经网络

class BRNN(nn.Module):def __init__(self, input_size, output_size, hidden_size, num_layers):super(BRNN, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True, bidirectional=True) # bidirectional为True是双向self.linear = nn.Linear(hidden_size * 2, output_size)  # 双向网络,因此有双倍hidden_sizedef forward(self, x):# 初始化隐藏状态state = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size) # 需要双倍的隐藏层output, _ = self.rnn(x, state)output = self.linear(output)return output
# 网络结构
model = BRNN(16, 16, 64, 2)
for name,parameters in model.named_parameters():print(name,':',parameters.size())

隐藏层的维度64

rnn.weight_ih_l0 : torch.Size([64, 16])
rnn.weight_hh_l0 : torch.Size([64, 64])
rnn.bias_ih_l0 : torch.Size([64])
rnn.bias_hh_l0 : torch.Size([64])
rnn.weight_ih_l0_reverse : torch.Size([64, 16])
rnn.weight_hh_l0_reverse : torch.Size([64, 64])
rnn.bias_ih_l0_reverse : torch.Size([64])
rnn.bias_hh_l0_reverse : torch.Size([64])
rnn.weight_ih_l1 : torch.Size([64, 128])
rnn.weight_hh_l1 : torch.Size([64, 64])
rnn.bias_ih_l1 : torch.Size([64])
rnn.bias_hh_l1 : torch.Size([64])
rnn.weight_ih_l1_reverse : torch.Size([64, 128])
rnn.weight_hh_l1_reverse : torch.Size([64, 64])
rnn.bias_ih_l1_reverse : torch.Size([64])
rnn.bias_hh_l1_reverse : torch.Size([64])
linear.weight : torch.Size([16, 128])
linear.bias : torch.Size([16])

1.3 长短期记忆网络

class LSTM(nn.Module):def __init__(self, input_size, output_size, hidden_size, num_layers):super(LSTM, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) # LSTMself.linear = nn.Linear(hidden_size, output_size)def forward(self, x):output, _ = self.lstm(x)output = self.linear(output)return output
# 网络结构
model = LSTM(16, 16, 64, 2)
for name,parameters in model.named_parameters():print(name,':',parameters.size())

隐藏层的维度 256 ,四个矩阵 f i c o,4个64的维度。

lstm.weight_ih_l0 : torch.Size([256, 16])
lstm.weight_hh_l0 : torch.Size([256, 64])
lstm.bias_ih_l0 : torch.Size([256])
lstm.bias_hh_l0 : torch.Size([256])
lstm.weight_ih_l1 : torch.Size([256, 64])
lstm.weight_hh_l1 : torch.Size([256, 64])
lstm.bias_ih_l1 : torch.Size([256])
lstm.bias_hh_l1 : torch.Size([256])
linear.weight : torch.Size([16, 64])
linear.bias : torch.Size([16])

1.4 门控循环单元

class GRU(nn.Module):def __init__(self, input_size, output_size, hidden_size, num_layers):super(GRU, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True) # GRUself.linear = nn.Linear(hidden_size, output_size)def forward(self, x):output, _ = self.gru(x)output = self.linear(output)return output
# 网络结构
model = GRU(16, 16, 64, 2)
for name,parameters in model.named_parameters():print(name,':',parameters.size())

两个门~ r h z即 64x3!

gru.weight_ih_l0 : torch.Size([192, 16])
gru.weight_hh_l0 : torch.Size([192, 64])
gru.bias_ih_l0 : torch.Size([192])
gru.bias_hh_l0 : torch.Size([192])
gru.weight_ih_l1 : torch.Size([192, 64])
gru.weight_hh_l1 : torch.Size([192, 64])
gru.bias_ih_l1 : torch.Size([192])
gru.bias_hh_l1 : torch.Size([192])
linear.weight : torch.Size([16, 64])
linear.bias : torch.Size([16])

5.2. 模型实验

2.1 数据集加载

import pandas_datareader as pdr
dji = pdr.DataReader('^DJI', 'stooq')
dji
OpenHighLowCloseVolume
Date
2023-02-1033671.5433897.3133591.9933869.27289863415.0
2023-02-0934105.6134252.5733607.1333699.88352340883.0
2023-02-0834132.9034161.6533899.7933949.01331798754.0
2023-02-0733769.7834240.0033634.1034156.69362844008.0
2023-02-0633874.4433962.8433683.5833891.02297051674.0
..................
2018-02-2025124.9125179.0124884.1924964.75421529658.0
2018-02-1625165.9425432.4225149.2625219.38406774321.0
2018-02-1525047.8225203.9524809.4225200.37416778260.0
2018-02-1424535.8224925.9524490.3624893.49431152512.0
2018-02-1324540.3324705.7224421.0324640.45374415694.0

1258 rows × 5 columns

import matplotlib.pyplot as plt
plt.plot(dji['Close'])
plt.show()

import torch
from torch.utils.data import DataLoader, TensorDatasetnum = len(dji)                           # 总数据量
x = torch.tensor(dji['Close'].to_list())  # 股价列表x = (x - torch.mean(x)) / torch.std(x)  #数据归一化seq_len = 16                               # 预测序列长度
batch_size = 16                            # 设置批大小X_feature = torch.zeros((num - seq_len, seq_len))      # 构建特征矩阵,num-seq_len行,seq_len列,初始值均为0
Y_label = torch.zeros((num - seq_len, seq_len))        # 构建标签矩阵,形状同特征矩阵
for i in range(seq_len):X_feature[:, i] = x[i: num - seq_len + i]    # 为特征矩阵赋值Y_label[:, i] = x[i+1: num - seq_len + i + 1]    # 为标签矩阵赋值train_loader = DataLoader(TensorDataset(X_feature[:num-seq_len].unsqueeze(2), Y_label[:num-seq_len]),batch_size=batch_size, shuffle=True)  # 构建数据加载器
# 定义超参数
input_size = 1
output_size = 1
num_hiddens = 64
n_layers = 2
lr = 0.001# 建立模型
model = DRNN(input_size, output_size, num_hiddens, n_layers)
criterion = nn.MSELoss(reduction='none')
trainer = torch.optim.Adam(model.parameters(), lr)
# 训练轮次
num_epochs = 20
rnn_loss_history = []for epoch in tqdm(range(num_epochs)):# 批量训练for X, Y in train_loader:trainer.zero_grad()y_pred = model(X)loss = criterion(y_pred.squeeze(), Y.squeeze())loss.sum().backward()trainer.step()# 输出损失model.eval()with torch.no_grad():total_loss = 0for X, Y in train_loader:y_pred = model(X)loss = criterion(y_pred.squeeze(), Y.squeeze())total_loss += loss.sum()/loss.numel()avg_loss = total_loss / len(train_loader)print(f'Epoch {epoch+1}: Validation loss = {avg_loss:.4f}')rnn_loss_history.append(avg_loss)# 绘制损失曲线图
import matplotlib.pyplot as plt
# plt.plot(loss_history, label='loss')
plt.plot(rnn_loss_history, label='RNN_loss')
plt.legend()
plt.show()
  5%|▌         | 1/20 [00:00<00:08,  2.30it/s]Epoch 1: Validation loss = 0.018010%|█         | 2/20 [00:00<00:07,  2.29it/s]Epoch 2: Validation loss = 0.008315%|█▌        | 3/20 [00:01<00:07,  2.29it/s]Epoch 3: Validation loss = 0.008120%|██        | 4/20 [00:01<00:06,  2.29it/s]Epoch 4: Validation loss = 0.007925%|██▌       | 5/20 [00:02<00:06,  2.29it/s]Epoch 5: Validation loss = 0.007830%|███       | 6/20 [00:02<00:06,  2.28it/s]Epoch 6: Validation loss = 0.007735%|███▌      | 7/20 [00:03<00:05,  2.27it/s]Epoch 7: Validation loss = 0.008140%|████      | 8/20 [00:03<00:05,  2.28it/s]Epoch 8: Validation loss = 0.008045%|████▌     | 9/20 [00:03<00:04,  2.28it/s]Epoch 9: Validation loss = 0.007850%|█████     | 10/20 [00:04<00:04,  2.25it/s]Epoch 10: Validation loss = 0.008055%|█████▌    | 11/20 [00:04<00:03,  2.25it/s]Epoch 11: Validation loss = 0.007960%|██████    | 12/20 [00:05<00:03,  2.25it/s]Epoch 12: Validation loss = 0.007965%|██████▌   | 13/20 [00:05<00:03,  2.27it/s]Epoch 13: Validation loss = 0.007770%|███████   | 14/20 [00:06<00:02,  2.25it/s]Epoch 14: Validation loss = 0.008275%|███████▌  | 15/20 [00:06<00:02,  2.26it/s]Epoch 15: Validation loss = 0.008080%|████████  | 16/20 [00:07<00:01,  2.25it/s]Epoch 16: Validation loss = 0.007785%|████████▌ | 17/20 [00:07<00:01,  2.26it/s]Epoch 17: Validation loss = 0.007890%|█████████ | 18/20 [00:07<00:00,  2.28it/s]Epoch 18: Validation loss = 0.007695%|█████████▌| 19/20 [00:08<00:00,  2.28it/s]Epoch 19: Validation loss = 0.0076
100%|██████████| 20/20 [00:08<00:00,  2.27it/s]Epoch 20: Validation loss = 0.0076

rnn_preds = model(X_feature.unsqueeze(2))
rnn_preds.squeeze()
time = torch.arange(1, num+1, dtype= torch.float32)  # 时间轴plt.plot(time[:num-seq_len], x[seq_len:num], label='dji')
# plt.plot(time[:num-seq_len], preds.detach().numpy(), label='preds')
plt.plot(time[:num-seq_len], rnn_preds[:,seq_len-1].detach(), label='RNN_preds')
plt.legend()
plt.show()

5.3 效果对比

# 定义超参数
input_size = 1
output_size = 1
num_hiddens = 64
n_layers = 2
lr = 0.001# 建立模型
model_name = ['DRNN', 'BRNN', 'LSTM', 'GRU']
drnn = DRNN(input_size, output_size, num_hiddens, n_layers)
brnn = BRNN(input_size, output_size, num_hiddens, n_layers)
lstm = LSTM(input_size, output_size, num_hiddens, n_layers)
gru = GRU(input_size, output_size, num_hiddens, n_layers)
models = [drnn, brnn, lstm, gru]opts = [torch.optim.Adam(drnn.parameters(), lr), torch.optim.Adam(brnn.parameters(), lr), torch.optim.Adam(lstm.parameters(), lr), torch.optim.Adam(gru.parameters(), lr)]
criterion = nn.MSELoss(reduction='none')num_epochs = 20
rnn_loss_history = []
lr = 0.1
for epoch in tqdm(range(num_epochs)):# 批量训练for X, Y in train_loader:for index, model, optimizer in zip(range(len(models)), models, opts):y_pred = model(X)loss = criterion(y_pred.squeeze(), Y.squeeze())trainer.zero_grad()loss.sum().backward()trainer.step()
100%|██████████| 20/20 [00:59<00:00,  2.95s/it]
for i in range(4):rnn_preds = models[i](X_feature.unsqueeze(2))bias = torch.sum(x[seq_len:num] - rnn_preds[:,seq_len-1].detach().numpy())print ('{} bias : {}'.format(model_name[i],str(bias)))
DRNN bias : tensor(125995.9453)
BRNN bias : tensor(-24902.6758)
LSTM bias : tensor(130150.6797)
GRU bias : tensor(102981.3438)

参考来源

Chapter-10/10.5 复杂循环神经网络代码实现.ipynb · 梗直哥/Deep-Learning-Code - Gitee.com

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

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

相关文章

算法与数据结构--特殊有序集的线性时间排序算法

一.计数排序算法 基本思想&#xff1a;统计每个输入元素的个数&#xff0c;然后根据这些计数值重构原数组。 使用范围&#xff1a;需要知道元素大小范围&#xff0c;就是最大值是多少。 【排序算法】计数排序_哔哩哔哩_bilibili 二.基数排序 使用场景&#xff1a;只适用于…

Laravel的知识点

1.{{ }} 是在 HTML 中内嵌 PHP 的 Blade 语法标识符&#xff0c;表示包含在该区块内的代码都将使用 PHP 来编译运行。 2.两种写法 3.return void 在这段注释中&#xff0c;"return void" 表示该函数或方法没有返回值。这意味着它执行某些操作或任务&#xff0c;但…

论文阅读《Rethinking Efficient Lane Detection via Curve Modeling》

目录 Abstract 1. Introduction 2. Related Work 3. BezierLaneNet 3.1. Overview 3.2. Feature Flip Fusion 3.3. End-to-end Fit of a Bezier Curve 4. Experiments 4.1. Datasets 4.2. Evalutaion Metics 4.3. Implementation Details 4.4. Comparisons 4.5. A…

使用克魔助手进行iOS数据抓包和HTTP抓包的方法详解

摘要 本文博客将介绍如何在iOS环境下使用克魔助手进行数据抓包和HTTP抓包。通过抓包&#xff0c;开发者可以分析移动应用程序的网络请求发送和接收过程&#xff0c;识别潜在的性能和安全问题&#xff0c;提高应用的质量和安全性。 引言 在移动应用程序的开发和测试过程中&am…

Linux磁盘与文件系统管理

目录 在linux系统中使用硬盘 磁盘的数据结构 磁盘接口类型 字母含义 MBR磁盘分区 分区类型 分区的缺点 文件系统的 文件系统有什么作用 文件系统的修复 检测并确认新磁盘 参看磁盘信息 查看磁盘信息 添加磁盘 查看添加磁盘情况&#xff1a;sda系统磁盘&#xff…

每周一算法:区间覆盖

问题描述 给定 N N N个闭区间 [ a i , b i ] [a_i,b_i] [ai​,bi​]&#xff0c;以及一个线段区间 [ s , t ] [s,t] [s,t]&#xff0c;请你选择尽量少的区间&#xff0c;将指定线段区间完全覆盖。 输出最少区间数&#xff0c;如果无法完全覆盖则输出 − 1 -1 −1。 输入格式…

【自然语言处理】第3部分:识别文本中的个人身份信息

自我介绍 做一个简单介绍&#xff0c;酒架年近48 &#xff0c;有20多年IT工作经历&#xff0c;目前在一家500强做企业架构&#xff0e;因为工作需要&#xff0c;另外也因为兴趣涉猎比较广&#xff0c;为了自己学习建立了三个博客&#xff0c;分别是【全球IT瞭望】&#xff0c;【…

解决Hive在DataGrip 中注释乱码问题

注释属于元数据的一部分&#xff0c;同样存储在mysql的metastore库中&#xff0c;如果metastore库的字符集不支持中文&#xff0c;就会导致中文显示乱码。 不建议修改Hive元数据库的编码&#xff0c;此处我们在metastore中找存储注释的表&#xff0c;找到表中存储注释的字段&a…

软件测试/测试开发丨Python学习笔记之基本数据类型与操作

一、变量 1、变量的定义&#xff1a; a. 在python中&#xff0c;变量是一种存储数据的载体。计算机中的变量是实际存在的数据或者说是存储器中存储数据的一块内存空间&#xff1b; b.变量的值可以被读取和修改。 2、命名规则&#xff1a; a.变量名由字母&#xff08;广义的Unic…

Python 常用模块Logging

Python 常用模块Logging 【序言】 logging模块是专门用来做日志记录的模块 【一】日志等级 默认打印结果到终端上 CRITICAL 50 # 致命错误 ERROR 40 # 错误 WARNING 30 # 警告 INFO 20 # 消息 DEBUG 10 # 调试 NOTSET 0 # 不设置示例&#xff1a; 默认级别为…

Unity引擎有哪些优点

Unity引擎是一款跨平台的游戏引擎&#xff0c;拥有很多的优点&#xff0c;如跨平台支持、强大的工具和编辑器、灵活的脚本支持、丰富的资源库和强大的社区生态系统等&#xff0c;让他成为众多开发者选择的游戏开发引擎。下面我简单的介绍一下Unity引擎的优点。 跨平台支持 跨…

自动化网络故障修复管理

什么是故障管理 故障管理是网络管理的组成部分&#xff0c;涉及检测、隔离和解决问题。如果实施得当&#xff0c;网络故障管理可以使连接、应用程序和服务保持在最佳水平&#xff0c;提供容错能力并最大限度地减少停机时间。专门为此目的设计的平台或工具称为故障管理系统。 …

WPF实战项目二十二(客户端):首页添加备忘录与待办事项

1、在View文件夹下新建文件夹Dialog&#xff0c;新建View&#xff1a;AddMemoView、AddToDoView <UserControlx:Class"WPFProject.Views.Dialogs.AddToDoView"xmlns"http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x"http://s…

推荐五款简洁而实用的工具,值得你尝试

​ 分享快乐是生活中美好的瞬间&#xff0c;而分享简单巧妙的工具也能令我愉悦。这五款工具简洁而实用&#xff0c;值得你尝试。 1.视频播放器——Potplayer Potplayer是一款视频播放器&#xff0c;支持DXVA、CUDA和QuickSync等硬件加速技术&#xff0c;提供高效的视频播放性…

关于Java并发、JVM面试题

前言 之前为了准备面试&#xff0c;收集整理了一些面试题。 本篇文章更新时间2023年12月27日。 最新的内容可以看我的原文&#xff1a;https://www.yuque.com/wfzx/ninzck/cbf0cxkrr6s1kniv 并发 进程与线程的区别 线程属于进程&#xff0c;进程可以拥有多个线程。进程独享…

【论文阅读】Resource Allocation for Text Semantic Communications

这是一篇关于语义通信中资源分配的论文。全文共5页&#xff0c;篇幅较短。 目录在这里 摘要关键字引言语义通信资源分配贡献公式符号 系统模型DeepSC TransmitterTransmission ModelDeepSC Receiver 语义感知资源分配策略Semantic Spectral Efficiency &#xff08;S-SE&#…

C++初阶(十七)模板进阶

&#x1f4d8;北尘_&#xff1a;个人主页 &#x1f30e;个人专栏:《Linux操作系统》《经典算法试题 》《C》 《数据结构与算法》 ☀️走在路上&#xff0c;不忘来时的初心 文章目录 一、非类型模板参数二、模板的特化1、概念2、函数模板特化3、类模板特化1、全特化2、偏特化 三…

Python爬虫篇(四):京东数据批量采集

京东数据批量采集 ●前言 一年一度的端午节又到了&#xff0c;甜咸粽子之争也拉开了帷幕&#xff0c;它价格高昂&#xff0c;它味道鲜美&#xff0c;然而&#xff0c;默默无名的它却备受广大民众喜爱&#xff01;好家伙&#xff0c;一看就是老qq看点了 &#xff0c;那咱们能做…

Flink1.17实战教程(第七篇:Flink SQL)

系列文章目录 Flink1.17实战教程&#xff08;第一篇&#xff1a;概念、部署、架构&#xff09; Flink1.17实战教程&#xff08;第二篇&#xff1a;DataStream API&#xff09; Flink1.17实战教程&#xff08;第三篇&#xff1a;时间和窗口&#xff09; Flink1.17实战教程&…

聚焦亚马逊云科技 re:Invent re:Cap专场,重构生成式AI的无限可能!

摘要&#xff1a;12月14日至17日&#xff0c;第十二届全球软件案例研究峰会(简称TOP100summit)在北京国际会议中心成功举办&#xff0c;亚马逊云科技资深开发者布道师郑予彬、亚马逊云科技解决方案研发中心应用科学家肖宇、可以科技产品负责人曹临杰、亚马逊云科技解决方案架构…