深度学习作业十 BPTT

目录

习题6-1P 推导RNN反向传播算法BPTT.

习题6-2 推导公式(6.40)和公式(6.41)中的梯度．

习题6-3 当使用公式(6.50)作为循环神经网络的状态更新公式时， 分析其可能存在梯度爆炸的原因并给出解决方法．

习题6-2P 设计简单RNN模型，分别用Numpy、Pytorch实现反向传播算子，并代入数值测试.

（1）RNNCell前向传播

（2）RNNcell反向传播

（3）RNN前向传播

（4）RNN反向传播

（5）分别用numpy和torch实现前向和反向传播

习题6-1P 推导RNN反向传播算法BPTT.

习题6-2 推导公式(6.40)和公式(6.41)中的梯度．

习题6-3 当使用公式(6.50)作为循环神经网络的状态更新公式时， 分析其可能存在梯度爆炸的原因并给出解决方法．

解决方法：

可以通过引入门控机制来进一步改进模型，主要有：长短期记忆网络（LSTM）和门控循环单元网络（GRU）。

LSTM：

LSTM 通过引入多个门控机制（输入门、遗忘门和输出门）以及一个独立的细胞状态（Cell State），来实现对信息的选择性记忆和遗忘，从而捕捉长序列的依赖关系。

关键组件：

优点
  • 能够捕捉长期依赖关系。
  • 对梯度消失问题有较好的抑制效果。
缺点
  • 结构复杂，参数较多，训练时间长。
  • 在某些任务中可能存在过拟合问题。

GRU：

GRU 是 LSTM 的简化版本，融合了遗忘门和输入门，减少了网络的复杂性，同时保持了对长序列依赖关系的建模能力。

优点
  • 参数比 LSTM 更少，计算效率更高。
  • 能在某些任务中达到与 LSTM 类似的性能。
缺点
  • 不具备 LSTM 的完全灵活性，在极长序列任务中可能表现略逊色。

习题6-2P 设计简单RNN模型，分别用Numpy、Pytorch实现反向传播算子，并代入数值测试.

（1）RNNCell前向传播

代码如下：

# ======RNNcell前向传播==================================================================
def rnn_cell_forward(xt, a_prev, parameters):
    # Retrieve parameters from "parameters"
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]

    ### START CODE HERE ### (≈2 lines)
    # compute next activation state using the formula given above
    a_next = np.tanh(np.dot(Wax, xt) + np.dot(Waa, a_prev) + ba)
    # compute output of the current cell using the formula given above
    yt_pred = F.softmax(torch.from_numpy(np.dot(Wya, a_next) + by), dim=0)
    ### END CODE HERE ###

    # store values you need for backward propagation in cache
    cache = (a_next, a_prev, xt, parameters)

    return a_next, yt_pred, cache


np.random.seed(1)
xt = np.random.randn(3, 10)
a_prev = np.random.randn(5, 10)
Waa = np.random.randn(5, 5)
Wax = np.random.randn(5, 3)
Wya = np.random.randn(2, 5)
ba = np.random.randn(5, 1)
by = np.random.randn(2, 1)
parameters = {"Waa": Waa, "Wax": Wax, "Wya": Wya, "ba": ba, "by": by}

a_next, yt_pred, cache = rnn_cell_forward(xt, a_prev, parameters)
print("a_next[4] = ", a_next[4])
print("a_next.shape = ", a_next.shape)
print("yt_pred[1] =", yt_pred[1])
print("yt_pred.shape = ", yt_pred.shape)
print("===================================================================")

运行结果：

（2）RNNcell反向传播

代码如下：

# ======RNNcell反向传播========================================================
def rnn_cell_backward(da_next, cache):
    # Retrieve values from cache
    (a_next, a_prev, xt, parameters) = cache

    # Retrieve values from parameters
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]

    ### START CODE HERE ###
    # compute the gradient of tanh with respect to a_next (≈1 line)
    dtanh = (1 - a_next * a_next) * da_next  # 注意这里是 element_wise ,即 * da_next，dtanh 可以只看做一个中间结果的表示方式

    # compute the gradient of the loss with respect to Wax (≈2 lines)
    dxt = np.dot(Wax.T, dtanh)
    dWax = np.dot(dtanh, xt.T)
    # 根据公式1、2， dxt =  da_next .(  Wax.T  . (1- tanh(a_next)**2) ) = da_next .(  Wax.T  . dtanh * (1/d_a_next) )= Wax.T  . dtanh
    # 根据公式1、3， dWax =  da_next .( (1- tanh(a_next)**2) . xt.T) = da_next .(  dtanh * (1/d_a_next) . xt.T )=  dtanh . xt.T
    # 上面的 . 表示 np.dot

    # compute the gradient with respect to Waa (≈2 lines)
    da_prev = np.dot(Waa.T, dtanh)
    dWaa = np.dot(dtanh, a_prev.T)

    # compute the gradient with respect to b (≈1 line)
    dba = np.sum(dtanh, keepdims=True, axis=-1)  # axis=0 列方向上操作 axis=1 行方向上操作  keepdims=True 矩阵的二维特性

    ### END CODE HERE ###

    # Store the gradients in a python dictionary
    gradients = {"dxt": dxt, "da_prev": da_prev, "dWax": dWax, "dWaa": dWaa, "dba": dba}

    return gradients


np.random.seed(1)
xt = np.random.randn(3, 10)
a_prev = np.random.randn(5, 10)
Wax = np.random.randn(5, 3)
Waa = np.random.randn(5, 5)
Wya = np.random.randn(2, 5)
b = np.random.randn(5, 1)
by = np.random.randn(2, 1)
parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "ba": ba, "by": by}

a_next, yt, cache = rnn_cell_forward(xt, a_prev, parameters)

da_next = np.random.randn(5, 10)
gradients = rnn_cell_backward(da_next, cache)
print("gradients[\"dxt\"][1][2] =", gradients["dxt"][1][2])
print("gradients[\"dxt\"].shape =", gradients["dxt"].shape)
print("gradients[\"da_prev\"][2][3] =", gradients["da_prev"][2][3])
print("gradients[\"da_prev\"].shape =", gradients["da_prev"].shape)
print("gradients[\"dWax\"][3][1] =", gradients["dWax"][3][1])
print("gradients[\"dWax\"].shape =", gradients["dWax"].shape)
print("gradients[\"dWaa\"][1][2] =", gradients["dWaa"][1][2])
print("gradients[\"dWaa\"].shape =", gradients["dWaa"].shape)
print("gradients[\"dba\"][4] =", gradients["dba"][4])
print("gradients[\"dba\"].shape =", gradients["dba"].shape)
gradients["dxt"][1][2] = -0.4605641030588796
gradients["dxt"].shape = (3, 10)
gradients["da_prev"][2][3] = 0.08429686538067724
gradients["da_prev"].shape = (5, 10)
gradients["dWax"][3][1] = 0.39308187392193034
gradients["dWax"].shape = (5, 3)
gradients["dWaa"][1][2] = -0.28483955786960663
gradients["dWaa"].shape = (5, 5)
gradients["dba"][4] = [0.80517166]
gradients["dba"].shape = (5, 1)
print("================================================================")

运行结果：

（3）RNN前向传播

代码如下：

# ====RNN前向传播==============================================================
def rnn_forward(x, a0, parameters):
    # Initialize "caches" which will contain the list of all caches
    caches = []

    # Retrieve dimensions from shapes of x and Wy
    n_x, m, T_x = x.shape
    n_y, n_a = parameters["Wya"].shape

    ### START CODE HERE ###

    # initialize "a" and "y" with zeros (≈2 lines)
    a = np.zeros((n_a, m, T_x))
    y_pred = np.zeros((n_y, m, T_x))

    # Initialize a_next (≈1 line)
    a_next = a0

    # loop over all time-steps
    for t in range(T_x):
        # Update next hidden state, compute the prediction, get the cache (≈1 line)
        a_next, yt_pred, cache = rnn_cell_forward(x[:, :, t], a_next, parameters)
        # Save the value of the new "next" hidden state in a (≈1 line)
        a[:, :, t] = a_next
        # Save the value of the prediction in y (≈1 line)
        y_pred[:, :, t] = yt_pred
        # Append "cache" to "caches" (≈1 line)
        caches.append(cache)

    ### END CODE HERE ###

    # store values needed for backward propagation in cache
    caches = (caches, x)

    return a, y_pred, caches


np.random.seed(1)
x = np.random.randn(3, 10, 4)
a0 = np.random.randn(5, 10)
Waa = np.random.randn(5, 5)
Wax = np.random.randn(5, 3)
Wya = np.random.randn(2, 5)
ba = np.random.randn(5, 1)
by = np.random.randn(2, 1)
parameters = {"Waa": Waa, "Wax": Wax, "Wya": Wya, "ba": ba, "by": by}

a, y_pred, caches = rnn_forward(x, a0, parameters)
print("a[4][1] = ", a[4][1])
print("a.shape = ", a.shape)
print("y_pred[1][3] =", y_pred[1][3])
print("y_pred.shape = ", y_pred.shape)
print("caches[1][1][3] =", caches[1][1][3])
print("len(caches) = ", len(caches))
print("=============================================================")

运行结果：

（4）RNN反向传播

代码如下：

# =====RNN反向传播=================================================================
def rnn_backward(da, caches):
    ### START CODE HERE ###
    # Retrieve values from the first cache (t=1) of caches (≈2 lines)
    (caches, x) = caches
    (a1, a0, x1, parameters) = caches[0]  # t=1 时的值

    # Retrieve dimensions from da's and x1's shapes (≈2 lines)
    n_a, m, T_x = da.shape
    n_x, m = x1.shape

    # initialize the gradients with the right sizes (≈6 lines)
    dx = np.zeros((n_x, m, T_x))
    dWax = np.zeros((n_a, n_x))
    dWaa = np.zeros((n_a, n_a))
    dba = np.zeros((n_a, 1))
    da0 = np.zeros((n_a, m))
    da_prevt = np.zeros((n_a, m))

    # Loop through all the time steps
    for t in reversed(range(T_x)):
        # Compute gradients at time step t. Choose wisely the "da_next" and the "cache" to use in the backward propagation step. (≈1 line)
        gradients = rnn_cell_backward(da[:, :, t] + da_prevt, caches[t])  # da[:,:,t] + da_prevt ，每一个时间步后更新梯度
        # Retrieve derivatives from gradients (≈ 1 line)
        dxt, da_prevt, dWaxt, dWaat, dbat = gradients["dxt"], gradients["da_prev"], gradients["dWax"], gradients[
            "dWaa"], gradients["dba"]
        # Increment global derivatives w.r.t parameters by adding their derivative at time-step t (≈4 lines)
        dx[:, :, t] = dxt
        dWax += dWaxt
        dWaa += dWaat
        dba += dbat

    # Set da0 to the gradient of a which has been backpropagated through all time-steps (≈1 line)
    da0 = da_prevt
    ### END CODE HERE ###

    # Store the gradients in a python dictionary
    gradients = {"dx": dx, "da0": da0, "dWax": dWax, "dWaa": dWaa, "dba": dba}

    return gradients


np.random.seed(1)
x = np.random.randn(3, 10, 4)
a0 = np.random.randn(5, 10)
Wax = np.random.randn(5, 3)
Waa = np.random.randn(5, 5)
Wya = np.random.randn(2, 5)
ba = np.random.randn(5, 1)
by = np.random.randn(2, 1)
parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "ba": ba, "by": by}
a, y, caches = rnn_forward(x, a0, parameters)
da = np.random.randn(5, 10, 4)
gradients = rnn_backward(da, caches)

print("gradients[\"dx\"][1][2] =", gradients["dx"][1][2])
print("gradients[\"dx\"].shape =", gradients["dx"].shape)
print("gradients[\"da0\"][2][3] =", gradients["da0"][2][3])
print("gradients[\"da0\"].shape =", gradients["da0"].shape)
print("gradients[\"dWax\"][3][1] =", gradients["dWax"][3][1])
print("gradients[\"dWax\"].shape =", gradients["dWax"].shape)
print("gradients[\"dWaa\"][1][2] =", gradients["dWaa"][1][2])
print("gradients[\"dWaa\"].shape =", gradients["dWaa"].shape)
print("gradients[\"dba\"][4] =", gradients["dba"][4])
print("gradients[\"dba\"].shape =", gradients["dba"].shape)
print("===========================================================")

运行结果：

（5）分别用numpy和torch实现前向和反向传播

代码如下：

# =====分别用numpy和torch实现前向和反向传播===================================================
import torch
import numpy as np


class RNNCell:
    def __init__(self, weight_ih, weight_hh,
                 bias_ih, bias_hh):
        self.weight_ih = weight_ih
        self.weight_hh = weight_hh
        self.bias_ih = bias_ih
        self.bias_hh = bias_hh

        self.x_stack = []
        self.dx_list = []
        self.dw_ih_stack = []
        self.dw_hh_stack = []
        self.db_ih_stack = []
        self.db_hh_stack = []

        self.prev_hidden_stack = []
        self.next_hidden_stack = []

        # temporary cache
        self.prev_dh = None

    def __call__(self, x, prev_hidden):
        self.x_stack.append(x)

        next_h = np.tanh(
            np.dot(x, self.weight_ih.T)
            + np.dot(prev_hidden, self.weight_hh.T)
            + self.bias_ih + self.bias_hh)

        self.prev_hidden_stack.append(prev_hidden)
        self.next_hidden_stack.append(next_h)
        # clean cache
        self.prev_dh = np.zeros(next_h.shape)
        return next_h

    def backward(self, dh):
        x = self.x_stack.pop()
        prev_hidden = self.prev_hidden_stack.pop()
        next_hidden = self.next_hidden_stack.pop()

        d_tanh = (dh + self.prev_dh) * (1 - next_hidden ** 2)
        self.prev_dh = np.dot(d_tanh, self.weight_hh)

        dx = np.dot(d_tanh, self.weight_ih)
        self.dx_list.insert(0, dx)

        dw_ih = np.dot(d_tanh.T, x)
        self.dw_ih_stack.append(dw_ih)

        dw_hh = np.dot(d_tanh.T, prev_hidden)
        self.dw_hh_stack.append(dw_hh)

        self.db_ih_stack.append(d_tanh)
        self.db_hh_stack.append(d_tanh)

        return self.dx_list


if __name__ == '__main__':
    np.random.seed(123)
    torch.random.manual_seed(123)
    np.set_printoptions(precision=6, suppress=True)

    rnn_PyTorch = torch.nn.RNN(4, 5).double()
    rnn_numpy = RNNCell(rnn_PyTorch.all_weights[0][0].data.numpy(),
                        rnn_PyTorch.all_weights[0][1].data.numpy(),
                        rnn_PyTorch.all_weights[0][2].data.numpy(),
                        rnn_PyTorch.all_weights[0][3].data.numpy())

    nums = 3
    x3_numpy = np.random.random((nums, 3, 4))
    x3_tensor = torch.tensor(x3_numpy, requires_grad=True)

    h3_numpy = np.random.random((1, 3, 5))
    h3_tensor = torch.tensor(h3_numpy, requires_grad=True)

    dh_numpy = np.random.random((nums, 3, 5))
    dh_tensor = torch.tensor(dh_numpy, requires_grad=True)

    h3_tensor = rnn_PyTorch(x3_tensor, h3_tensor)
    h_numpy_list = []

    h_numpy = h3_numpy[0]
    for i in range(nums):
        h_numpy = rnn_numpy(x3_numpy[i], h_numpy)
        h_numpy_list.append(h_numpy)

    h3_tensor[0].backward(dh_tensor)
    for i in reversed(range(nums)):
        rnn_numpy.backward(dh_numpy[i])

    print("numpy_hidden :\n", np.array(h_numpy_list))
    print("torch_hidden :\n", h3_tensor[0].data.numpy())
    print("-----------------------------------------------")

    print("dx_numpy :\n", np.array(rnn_numpy.dx_list))
    print("dx_torch :\n", x3_tensor.grad.data.numpy())
    print("------------------------------------------------")

    print("dw_ih_numpy :\n",
          np.sum(rnn_numpy.dw_ih_stack, axis=0))
    print("dw_ih_torch :\n",
          rnn_PyTorch.all_weights[0][0].grad.data.numpy())
    print("------------------------------------------------")

    print("dw_hh_numpy :\n",
          np.sum(rnn_numpy.dw_hh_stack, axis=0))
    print("dw_hh_torch :\n",
          rnn_PyTorch.all_weights[0][1].grad.data.numpy())
    print("------------------------------------------------")

    print("db_ih_numpy :\n",
          np.sum(rnn_numpy.db_ih_stack, axis=(0, 1)))
    print("db_ih_torch :\n",
          rnn_PyTorch.all_weights[0][2].grad.data.numpy())
    print("-----------------------------------------------")
    print("db_hh_numpy :\n",
          np.sum(rnn_numpy.db_hh_stack, axis=(0, 1)))
    print("db_hh_torch :\n",
          rnn_PyTorch.all_weights[0][3].grad.data.numpy())

运行结果：

 这次的分享就到这里，下次再见~

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

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

相关文章

Css、less和Sass（SCSS）的区别详解

Css、less和Sass（SCSS）的区别详解

文章目录 Css、less和Sass（SCSS）的区别详解一、引言二、CSS 简介1.1、CSS 示例 三、Less 简介2.1、Less 特性2.2、Less 示例 四、Sass（SCSS）简介3.1、Sass 特性3.2、SCSS 示例 五、总结 Css、less和Sass（SCSS&#xff…
阅读更多...
WebHID API演示Demo教程：设备列表，设备连接，数据读写

WebHID API演示Demo教程：设备列表，设备连接，数据读写

1. 简介 WebHID API允许网页应用直接与HID（人机接口设备）进行通信。本教程将演示如何创建一个基础的WebHID应用，实现以下功能： 显示和获取HID设备列表连接/断开HID设备读取设备数据向设备发送数据 2. 兼容性和前提条件 2.1 浏览…
阅读更多...
R语言机器学习论文（六）：总结

R语言机器学习论文（六）：总结

文章目录 介绍参考文献介绍 本文采用R语言对来自进行数据描述、数据预处理、特征筛选和模型构建。 最后我们获得了一个能有效区分乳腺组织的随机森林预测模型，它的性能非常好，这意味着它可能拥有非常好的临床价值。 在本文中，我们利用R语言对来自美国加州大学欧文分校的B…
阅读更多...
三、代码管理-Git

三、代码管理-Git

文章目录 前言一、Git1. Git 与 SVN 区别2. Git 入门3. 客户端工具4. 主流Git仓库 二、GitLab1. 介绍2. 适合的场景 二、GitHub1. 介绍2. 适合的场景 三、Gitee1. 介绍2. 适合的场景 四、GitCode1. 介绍2. 适合的场景 五、总结 前言 代码托管‌ Git作为目前最为流行的版本控制…
阅读更多...
基于51单片机的智能公交车报站系统GPS定位语音播报智能安全检测人数统计

基于51单片机的智能公交车报站系统GPS定位语音播报智能安全检测人数统计

功能描述 1.LCD12864可显示当前年月日，星期，时间， 当前站名，经纬度，是否连接GPS，自动/手动模式， 2.自带GPS定位，可实时显示经纬度； 3.通过DS1302时钟芯片，获…
阅读更多...
【数据库系列】Spring Data Neo4j Cypher 查询使用进阶指南

【数据库系列】Spring Data Neo4j Cypher 查询使用进阶指南

在 Neo4j 中，Cypher 查询语句并不像 MySQL 的 mapper XML 那样直接支持拆分和组织。然而，你可以使用一些策略来管理和重用 Cypher 查询，使其更易于维护和组织。以下是几种方法： 1. 使用 Spring Data Neo4j 的 Repository 接口 通过定义多个查询方法，可以将复杂查询分解为…
阅读更多...
UIlicious - 自动化端到端测试

UIlicious - 自动化端到端测试

在现代软件开发中，测试自动化已然成为产品交付质量的基石。而端到端测试（E2E），作为验证整个应用流畅运行的关键，常常是测试工作中最具挑战性的一环。这时，一款简单高效的自动化测试工具——UIlicious&#…
阅读更多...
OpenHarmony-3.HDF框架（2）

OpenHarmony-3.HDF框架（2）

OpenHarmony HDF 平台驱动 1.平台驱动概述 系统平台驱动框架是系统驱动框架的重要组成部分，它基于HDF驱动框架、操作系统适配层(OSAL, operating system abstraction layer)以及驱动配置管理机制，为各类平台设备驱动的实现提供标准模型。 系统平台驱动(…
阅读更多...
前端 el-table-column 里加上el-form-item 上面有黑色悬浮

前端 el-table-column 里加上el-form-item 上面有黑色悬浮

如图所示 解决方法，查看你的 el-table-column 是否设置了 show-overflow-tooltip 属性，如果是去掉即可
阅读更多...
使用MATLAB从Excel文件读取数据并绘制堆叠柱状图

使用MATLAB从Excel文件读取数据并绘制堆叠柱状图

在数据可视化中，堆叠柱状图是展示多个变量相对比例的非常有效的方法。它通过将每个数据系列堆叠在一起，帮助我们理解不同数据类别在总量中所占的份额。在这篇博客中，我们将学习如何使用MATLAB从Excel文件导入数据，并使用渐变色来绘…
阅读更多...
书生浦语第四期--入门岛-第三关

书生浦语第四期--入门岛-第三关

文章目录 1.破冰任务：自我介绍1.1 create new fork1.2 git clone 自己的分支1.3 创建关联分支1.4提交修改 任务2 ：创建自己的仓库 1.破冰任务：自我介绍 1.1 create new fork 创建一个自己的分支，在自己分支上进行修改&#xff0…
阅读更多...
【AI系统】轻量级CNN模型新进展

【AI系统】轻量级CNN模型新进展

CNN 模型小型化（下） 在本文会接着介绍 CNN 模型的小型化，除了第二篇文章提到的三个模型外，在本章节会继续介绍 ESPNet 系列，FBNet 系列，EfficientNet 系列和 GhostNet 系列。 ESPNet 系列 ESPNetV1 ESP…
阅读更多...
鸿蒙HarmonyOS状态管理组件吐槽

鸿蒙HarmonyOS状态管理组件吐槽

吐槽一下鸿蒙系统设计的状态管理组件 一. 定义和作用 状态管理组件其本质作用用来修饰状态变量，这样可以观察到变量在组件内的改变，还可以在不同组件层级间传递，其设计初衷挺好。在声明式UI编程框架中，UI是程序状态的运行结果&a…
阅读更多...
unicloud微信小程序云端一体项目DEMO

unicloud微信小程序云端一体项目DEMO

最近应客户需求，做了一个产品展示的云开发小程序，从了解云开发到应用到实际项目的产品demo，希望大家能从中获取到对自己有用的东西。 说下心得体会吧，一般小项目用这种云开发确实会减少很多开发成本，人力成本&#xf…
阅读更多...
爬虫专栏第一篇：深入探索爬虫世界：基础原理、类型特点与规范要点全解析

爬虫专栏第一篇：深入探索爬虫世界：基础原理、类型特点与规范要点全解析

本专栏会对爬虫进行从0开始的讲解，每一步都十分的细致，如果你感兴趣希望多多点赞收藏关注支持 简介：文章对爬虫展开多方面剖析。起始于爬虫的基本概念，即依特定规则在网络抓取信息的程序或脚本，在搜索引擎信息提取上作…
阅读更多...
【Spring】Spring 整合 JUnit

【Spring】Spring 整合 JUnit

JUnit 是 Java 中一个广泛使用的单元测试框架。它使用简单的注解和断言方法，使开发者能够轻松编写和运行测试用例。在使用 IDEA 创建的 Spring 项目中，JUnit 框架可以方便地进行整合。下面是整合的具体步骤。这里使用一个之前整合 MyBatis 时的 Spring 项…
阅读更多...
MATLAB数学建模之画图汇总

MATLAB数学建模之画图汇总

MATLAB是一种强大的数学软件，广泛应用于工程计算、控制设计、信号处理等领域。在数学建模中，MATLAB的绘图功能可以帮助我们直观地展示数据和模型结果。 1. 二维数据曲线图 1.1 绘制二维曲线的基本函数 plot函数用于绘制二维平面上的线性坐标曲线图&am…
阅读更多...
Linux 远程连接服务

Linux 远程连接服务

远程连接服务器简介 什么是远程连接服务器 远程连接服务器通过文字或图形接口方式来远程登录系统，让你在远程终端前登录linux主机以取得可操 作主机接口（shell），而登录后的操作感觉就像是坐在系统前面一样。 远程连接服务器的功…
阅读更多...
Prometheus 采集postgresql监控数据

Prometheus 采集postgresql监控数据

postgres_exporter 前言 postgres_exporter 是一个用于监控 PostgreSQL 数据库的 Prometheus 导出器。它允许你收集有关 PostgreSQL 数据库性能和状态的指标，并将这些指标暴露给 Prometheus，从而可以在 Grafana 等可视化工具中进行展示和告警。 postgres_exporter download…
阅读更多...
windows文件下换行, linux上不换行 解决CR换行符替换为LF notepad++

windows文件下换行, linux上不换行 解决CR换行符替换为LF notepad++

html文件是用回车换行的，在windows电脑上，显示正常。 文件上传到linux服务器后，文件不换行了。只有一行。而且相关js插件也没法正常运行。 用notepad查看，显示尾部换行符，是CR，这就是原因。CR是不被识别的。…
阅读更多...
最新文章

Copyright @ 2022~2023