深度强化学习（DRL）算法 附录 6 —— NLP 回顾之预训练模型篇

Self-Attention

模型结构

上图架构以 batch_size 为 1，两个时间步的 X 为例子，计算过程如下：

位置编码

根据 self-attention 的模型结构，改变 X 的输入顺序，不影响 attention 的结果，所以还需要引入额外的位置信息，即位置编码。

图里计算机二进制编码的低位和位置编码矩阵的前面几列对应。

除了上面捕获绝对位置信息之外，上述的位置编码还允许模型学习得到输入序列中相对位置信息。 这是因为对于任何确定的位置偏移δ，位置 i+δ 处的位置编码可以线性投影位置 i 处的位置编码来表示。

\begin{aligned} & {\left[\begin{array}{cc} \cos \left(\delta \omega_j\right) & \sin \left(\delta \omega_j\right) \\ -\sin \left(\delta \omega_j\right) & \cos \left(\delta \omega_j\right) \end{array}\right]\left[\begin{array}{c} p_{i, 2 j} \\ p_{i, 2 j+1} \end{array}\right] } \\ = & {\left[\begin{array}{c} \cos \left(\delta \omega_j\right) \sin \left(i \omega_j\right)+\sin \left(\delta \omega_j\right) \cos \left(i \omega_j\right) \\ -\sin \left(\delta \omega_j\right) \sin \left(i \omega_j\right)+\cos \left(\delta \omega_j\right) \cos \left(i \omega_j\right) \end{array}\right] } \\ = & {\left[\begin{array}{l} \sin \left((i+\delta) \omega_j\right) \\ \cos \left((i+\delta) \omega_j\right) \end{array}\right] } \\ = & {\left[\begin{array}{c} p_{i+\delta, 2 j} \\ p_{i+\delta, 2 j+1} \end{array}\right] } \end{aligned}

代码

#@save
class PositionalEncoding(nn.Module):
    """位置编码"""
    def __init__(self, num_hiddens, dropout, max_len=1000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(dropout)
        # 创建一个足够长的P
        self.P = torch.zeros((1, max_len, num_hiddens))
        X = torch.arange(max_len, dtype=torch.float32).reshape(
            -1, 1) / torch.pow(10000, torch.arange(
            0, num_hiddens, 2, dtype=torch.float32) / num_hiddens)
        self.P[:, :, 0::2] = torch.sin(X)
        self.P[:, :, 1::2] = torch.cos(X)

    def forward(self, X):
        X = X + self.P[:, :X.shape[1], :].to(X.device)
        return self.dropout(X)

多头注意力

模型结构

  • 两头注意力

  • 七头注意力

添加图片注释，不超过 140 字（可选）

  • 七头注意力连接进行信息融合

  • 掩码多头注意力

和多头注意力是一样的，只不过每个头的 self-attention 变成了 masked self-attention

代码

import math
import torch
from torch import nn
from d2l import torch as d2l

#@save
def transpose_qkv(X, num_heads):
    """为了多注意力头的并行计算而变换形状"""
    # 输入X的形状:(batch_size，查询或者“键－值”对的个数，num_hiddens)
    # 输出X的形状:(batch_size，查询或者“键－值”对的个数，num_heads，
    # num_hiddens/num_heads)
    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)

    # 输出X的形状:(batch_size，num_heads，查询或者“键－值”对的个数,
    # num_hiddens/num_heads)
    X = X.permute(0, 2, 1, 3)

    # 最终输出的形状:(batch_size*num_heads,查询或者“键－值”对的个数,
    # num_hiddens/num_heads)
    return X.reshape(-1, X.shape[2], X.shape[3])


#@save
def transpose_output(X, num_heads):
    """逆转transpose_qkv函数的操作"""
    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])
    X = X.permute(0, 2, 1, 3)
    return X.reshape(X.shape[0], X.shape[1], -1)

#@save
class DotProductAttention(nn.Module):
    """Scaled dot product attention.
    Defined in :numref:`subsec_additive-attention`"""
    def __init__(self, dropout, **kwargs):
        super(DotProductAttention, self).__init__(**kwargs)
        self.dropout = nn.Dropout(dropout)

    # Shape of `queries`: (`batch_size`, no. of queries, `d`)
    # Shape of `keys`: (`batch_size`, no. of key-value pairs, `d`)
    # Shape of `values`: (`batch_size`, no. of key-value pairs, value
    # dimension)
    # Shape of `valid_lens`: (`batch_size`,) or (`batch_size`, no. of queries)
    def forward(self, queries, keys, values, valid_lens=None):
        d = queries.shape[-1]
        # Set `transpose_b=True` to swap the last two dimensions of `keys`
        scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)
        self.attention_weights = masked_softmax(scores, valid_lens)
        return torch.bmm(self.dropout(self.attention_weights), values)

#@save
class MultiHeadAttention(nn.Module):
    """多头注意力"""
    def __init__(self, key_size, query_size, value_size, num_hiddens,
                 num_heads, dropout, bias=False, **kwargs):
        super(MultiHeadAttention, self).__init__(**kwargs)
        self.num_heads = num_heads
        self.attention = d2l.DotProductAttention(dropout)
        self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)
        self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)
        self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)
        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)

    def forward(self, queries, keys, values, valid_lens):
        # queries，keys，values的形状:
        # (batch_size，查询或者“键－值”对的个数，num_hiddens)
        # valid_lens　的形状:
        # (batch_size，)或(batch_size，查询的个数)
        # 经过变换后，输出的queries，keys，values　的形状:
        # (batch_size*num_heads，查询或者“键－值”对的个数，
        # num_hiddens/num_heads)
        queries = transpose_qkv(self.W_q(queries), self.num_heads)
        keys = transpose_qkv(self.W_k(keys), self.num_heads)
        values = transpose_qkv(self.W_v(values), self.num_heads)

        if valid_lens is not None:
            # 在轴0，将第一项（标量或者矢量）复制num_heads次，
            # 然后如此复制第二项，然后诸如此类。
            valid_lens = torch.repeat_interleave(
                valid_lens, repeats=self.num_heads, dim=0)

        # output的形状:(batch_size*num_heads，查询的个数，
        # num_hiddens/num_heads)
        output = self.attention(queries, keys, values, valid_lens)

        # output_concat的形状:(batch_size，查询的个数，num_hiddens)
        output_concat = transpose_output(output, self.num_heads)
        return self.W_o(output_concat)

Transformer

模型结构

encoder

decoder

代码

import math
import pandas as pd
import torch
from torch import nn
from d2l import torch as d2l

#@save
class PositionWiseFFN(nn.Module):
    """基于位置的前馈网络"""
    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs,
                 **kwargs):
        super(PositionWiseFFN, self).__init__(**kwargs)
        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)
        self.relu = nn.ReLU()
        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)

    def forward(self, X):
        return self.dense2(self.relu(self.dense1(X)))

#@save
class AddNorm(nn.Module):
    """残差连接后进行层规范化"""
    def __init__(self, normalized_shape, dropout, **kwargs):
        super(AddNorm, self).__init__(**kwargs)
        self.dropout = nn.Dropout(dropout)
        self.ln = nn.LayerNorm(normalized_shape)

    def forward(self, X, Y):
        return self.ln(self.dropout(Y) + X)

#@save
class EncoderBlock(nn.Module):
    """Transformer编码器块"""
    def __init__(self, key_size, query_size, value_size, num_hiddens,
                 norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
                 dropout, use_bias=False, **kwargs):
        super(EncoderBlock, self).__init__(**kwargs)
        self.attention = d2l.MultiHeadAttention(
            key_size, query_size, value_size, num_hiddens, num_heads, dropout,
            use_bias)
        self.addnorm1 = AddNorm(norm_shape, dropout)
        self.ffn = PositionWiseFFN(
            ffn_num_input, ffn_num_hiddens, num_hiddens)
        self.addnorm2 = AddNorm(norm_shape, dropout)

    def forward(self, X, valid_lens):
        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))
        return self.addnorm2(Y, self.ffn(Y))

#@save
class TransformerEncoder(d2l.Encoder):
    """Transformer编码器"""
    def __init__(self, vocab_size, key_size, query_size, value_size,
                 num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
                 num_heads, num_layers, dropout, use_bias=False, **kwargs):
        super(TransformerEncoder, self).__init__(**kwargs)
        self.num_hiddens = num_hiddens
        self.embedding = nn.Embedding(vocab_size, num_hiddens)
        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
        self.blks = nn.Sequential()
        for i in range(num_layers):
            self.blks.add_module("block"+str(i),
                EncoderBlock(key_size, query_size, value_size, num_hiddens,
                             norm_shape, ffn_num_input, ffn_num_hiddens,
                             num_heads, dropout, use_bias))

    def forward(self, X, valid_lens, *args):
        # 因为位置编码值在-1和1之间，
        # 因此嵌入值乘以嵌入维度的平方根进行缩放，
        # 然后再与位置编码相加。
        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
        self.attention_weights = [None] * len(self.blks)
        for i, blk in enumerate(self.blks):
            X = blk(X, valid_lens)
            self.attention_weights[
                i] = blk.attention.attention.attention_weights
        return X

class DecoderBlock(nn.Module):
    """解码器中第i个块"""
    def __init__(self, key_size, query_size, value_size, num_hiddens,
                 norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
                 dropout, i, **kwargs):
        super(DecoderBlock, self).__init__(**kwargs)
        self.i = i
        self.attention1 = d2l.MultiHeadAttention(
            key_size, query_size, value_size, num_hiddens, num_heads, dropout)
        self.addnorm1 = AddNorm(norm_shape, dropout)
        self.attention2 = d2l.MultiHeadAttention(
            key_size, query_size, value_size, num_hiddens, num_heads, dropout)
        self.addnorm2 = AddNorm(norm_shape, dropout)
        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens,
                                   num_hiddens)
        self.addnorm3 = AddNorm(norm_shape, dropout)

    def forward(self, X, state):
        enc_outputs, enc_valid_lens = state[0], state[1]
        # 训练阶段，输出序列的所有词元都在同一时间处理，
        # 因此state[2][self.i]初始化为None。
        # 预测阶段，输出序列是通过词元一个接着一个解码的，
        # 因此state[2][self.i]包含着直到当前时间步第i个块解码的输出表示
        if state[2][self.i] is None:
            key_values = X
        else:
            key_values = torch.cat((state[2][self.i], X), axis=1)
        state[2][self.i] = key_values
        if self.training:
            batch_size, num_steps, _ = X.shape
            # dec_valid_lens的开头:(batch_size,num_steps),
            # 其中每一行是[1,2,...,num_steps]
            dec_valid_lens = torch.arange(
                1, num_steps + 1, device=X.device).repeat(batch_size, 1)
        else:
            dec_valid_lens = None

        # 自注意力
        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)
        Y = self.addnorm1(X, X2)
        # 编码器－解码器注意力。
        # enc_outputs的开头:(batch_size,num_steps,num_hiddens)
        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)
        Z = self.addnorm2(Y, Y2)
        return self.addnorm3(Z, self.ffn(Z)), state

class TransformerDecoder(d2l.AttentionDecoder):
    def __init__(self, vocab_size, key_size, query_size, value_size,
                 num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
                 num_heads, num_layers, dropout, **kwargs):
        super(TransformerDecoder, self).__init__(**kwargs)
        self.num_hiddens = num_hiddens
        self.num_layers = num_layers
        self.embedding = nn.Embedding(vocab_size, num_hiddens)
        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
        self.blks = nn.Sequential()
        for i in range(num_layers):
            self.blks.add_module("block"+str(i),
                DecoderBlock(key_size, query_size, value_size, num_hiddens,
                             norm_shape, ffn_num_input, ffn_num_hiddens,
                             num_heads, dropout, i))
        self.dense = nn.Linear(num_hiddens, vocab_size)

    def init_state(self, enc_outputs, enc_valid_lens, *args):
        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]

    def forward(self, X, state):
        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]
        for i, blk in enumerate(self.blks):
            X, state = blk(X, state)
            # 解码器自注意力权重
            self._attention_weights[0][
                i] = blk.attention1.attention.attention_weights
            # “编码器－解码器”自注意力权重
            self._attention_weights[1][
                i] = blk.attention2.attention.attention_weights
        return self.dense(X), state

    @property
    def attention_weights(self):
        return self._attention_weights

num_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10
lr, num_epochs, device = 0.005, 200, d2l.try_gpu()
ffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4
key_size, query_size, value_size = 32, 32, 32
norm_shape = [32]

train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)

encoder = TransformerEncoder(
    len(src_vocab), key_size, query_size, value_size, num_hiddens,
    norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
    num_layers, dropout)
decoder = TransformerDecoder(
    len(tgt_vocab), key_size, query_size, value_size, num_hiddens,
    norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
    num_layers, dropout)
net = d2l.EncoderDecoder(encoder, decoder)
d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)

Bert

bert 开启了预训练模型的风潮，使用了带掩码的语言模型，具体就是通过大量的数据，模型获取了语言信息抽取的能力，从而可以通过 fine-tune 应用到各种 NLP 任务上。

3w 的词典，使用了 WordPiece。[cls] A [seq] B [seq]

位置嵌入换成了学习的矩阵。

模型结构

截取了 transformer 的 encoder（代码没有改动）

不同点：

  • 输入

  • 训练（类似完形填空，以及下一个句子预测）

尽管掩蔽语言建模能够编码双向上下文来表示单词，但它不能显式地建模文本对之间的逻辑关系。为了帮助理解两个文本序列之间的关系，BERT在预训练中考虑了一个二元分类任务——下一句预测。在为预训练生成句子对时，有一半的时间它们确实是标签为“真”的连续句子；在另一半的时间里，第二个句子是从语料库中随机抽取的，标记为“假”。

模型参数计算

BERT-base（H = 768，L = 12，A = 12）

Transformer encoder block 里面主要参数有：

  1. 嵌入层：H x 30000（vocab_size 约等于 30000）

2. 全连接层：H x 4H + 4H x H（一个 block 里面有两个全连接层）

3. 多头注意力机制层：H x H / head_num x 3（一个头的参数，3代表 Q，K，V 用不同矩阵做线性变换），所有头加起来 H x H x 3，再加上多头注意力机制层的线性变换 H x H，这里可以结合下图理解：

添加图片注释，不超过 140 字（可选）

1，2，3 加起来就是 BERT-base 的参数数量。

计算公式： L*12H^{2} + 30000*H \approx 110M (H=768, L=12)

BERT-large 同理可以计算出参数数量约等于 340M。

GPT-3

截取了 transformer 的 decoder（代码没有改动）

参考

51 序列模型【动手学深度学习v2】-跟李沐学AI-【完结】动手学深度学习 PyTorch版-哔哩哔哩视频

8.1. 序列模型 - 动手学深度学习 2.0.0 documentation

Visualizing A Neural Machine Translation Model (Mechanics of Seq2seq Models With Attention)

The Illustrated Transformer

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

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

相关文章

解决Linux根分区空间不足的方法：利用Home分区进行扩容

解决Linux根分区空间不足的方法：利用Home分区进行扩容

前言 在进行系统安装时，一个常见的困扰是默认分区设置可能导致home分区拥有过多的空间，而root分区却显得十分紧缺。这种情况下，用户往往会陷入无法继续安装软件或存储文件的困境。本文将向您展示如何通过合理的调整，将home分区中多…
阅读更多...
《剑指 Offer》专项突破版 - 面试题 111 : 计算除法（C++ 实现）

《剑指 Offer》专项突破版 - 面试题 111 : 计算除法（C++ 实现）

题目链接：计算除法 题目： 输入两个数组 equations 和 values，其中，数组 equations 的每个元素包含两个表示变量名的字符串，数组 values 的每个元素是一个浮点数值。如果 equations[i] 的两个变量名分别是 和 &#…
阅读更多...
接口测试——postman

接口测试——postman

一.下载与安装 https://www.getPostman.com/ 界面导航说明 二.get请求 第一个get请求 批量执行接口请求： 1. 右击run collection 2. 会出现runner标签页 携带参数的GET请求 所谓的查询参数，其实就是URL地址中问号（?）后面的部分…
阅读更多...
易基因： MeRIP-seq揭示lncRNA甲基化通过lncRNA-miRNA/蛋白质轴抑制胃癌干细胞凋亡｜文献解读

易基因： MeRIP-seq揭示lncRNA甲基化通过lncRNA-miRNA/蛋白质轴抑制胃癌干细胞凋亡｜文献解读

大家好，这里是专注表观组学十余年，领跑多组学科研服务的易基因。 癌症一直是生物学研究的热门话题。关于癌症起源，一种主流观点是癌症干细胞（Cancer Stem Cell，CSC）的无限增殖。CSC是肿瘤内肿瘤细胞的一个…
阅读更多...
textview允许长文本下滑

textview允许长文本下滑

原本是用scroview textview的，结果长文本的时候，textview会把文本内容截断； 后面在网上找到直接使用textview就能解决长文本问题， 关键代码还是这两个 android:scrollbars“vertical” tv_message_message.setMovementMethod(…
阅读更多...
5.HC-05蓝牙模块

5.HC-05蓝牙模块

配置蓝牙模块 注意需要将蓝牙模块接5v,实测接3.3v好像不太好使的样子 首先需要把蓝牙模块通过TTL串口模块接到我们的电脑,然后打开我们的串口助手 注意,我们现在是配置蓝牙模块,所以需要进入AT模式,需要按着蓝牙模块上的黑色小按钮再上电,这时候模块上的LED灯以一秒慢闪一次…
阅读更多...
大数据平台搭建2024（三）

大数据平台搭建2024（三）

三：HBase安装 提前上传hbase安装包至虚拟机 1 上传、解压 tar -zxvf hbase-2.0.0-alpha2-bin.tar.gz -C /hadoop2 修改配置文件 在/hadoop/hbase-2.0.0-alpha2-bin/conf文件夹里 vi /hadoop/hbase-2.0.0-alpha2/conf/hbase-env.sh修改hbase-env.sh文件 export…
阅读更多...
错误分析 （Machine Learning研习十九）

错误分析 （Machine Learning研习十九）

错误分析 您将探索数据准备选项，尝试多个模型，筛选出最佳模型，使用 Grid SearchCV微调其超参数，并尽可能实现自动化。在此，我们假设您已经找到了一个有前途的模型，并希望找到改进它的方法。其中一种方法就…
阅读更多...
基于java+springboot+vue实现的健身俱乐部系统（文末源码+Lw+ppt）23-49

基于java+springboot+vue实现的健身俱乐部系统（文末源码+Lw+ppt）23-49

摘　要 随着社会的发展，健身俱乐部的管理形势越来越严峻。越来越多的用户利用互联网获得信息，健身信息鱼龙混杂，信息真假难以辨别。为了方便用户更好的获得本健身俱乐部管理信息，因此，设计一种安全高效的健身俱乐部网…
阅读更多...
React-基础语法学习

React-基础语法学习

1、教程：井字棋游戏 本教程将引导你逐步实现一个简单的井字棋游戏，并且不需要你对 React 有任何了解。在此过程中你会学习到一些编写 React 程序的基本知识，完全理解它们可以让你对 React 有比较深入的理解。 1.1、教程分成以下几个部分&am…
阅读更多...
计算机视觉动作识别——YOWO用于实时时空动作定位与识别的算法解析

计算机视觉动作识别——YOWO用于实时时空动作定位与识别的算法解析

摘要 时空动作定位要求将两种信息源整合到设计的架构中：(1) 来自先前帧的时间信息和(2) 来自关键帧的空间信息。当前的最先进方法通常使用单独的网络提取这些信息，并使用额外的机制进行融合以获得检测结果。YOWO是一个用于视频流中实时时空动作定位的统…
阅读更多...
宏集eX700M系列HMI实现港口设备数据上云

宏集eX700M系列HMI实现港口设备数据上云

前言 随着港口设备信息化技术的快速发展，越来越多的企业想要把现场设备数据上传到云平台，进而实现关键数据的远程监控和分析处理。在此背景下，国内某信息化公司想要将港口设备数据通过MQTT上传到该公司自研IOT平台，实现数据上云&…
阅读更多...
vue-treeselect 的基本使用

vue-treeselect 的基本使用

vue-treeselect 的基本使用 1. 效果展示2. 安装 插件3. 引入组件4. 代码 1. 效果展示 2. 安装 插件 vue-treeselect是一个树形的下拉菜单，至于到底有多少节点那就要看你的数据源有多少层了，挺方便的。下面这个这个不用多说吧，下载依赖 npm in…
阅读更多...
中兴通讯AI全场景终端新品 赋能行业数智化升级发布 (2)

中兴通讯AI全场景终端新品 赋能行业数智化升级发布 (2)

2024年4月11日，南京，在2024年中兴通讯云网生态峰会召开之际，中兴行业终端合作伙伴大会暨春季新品发布会也同期举行。本次大会主题为“强基拓新，价值创造”，中兴行业终端持续践行合作伙伴优先、深度定制更安全更高效的解…
阅读更多...
揭秘ebay、亚马逊测评系统：从稳定环境搭建到防关联技术

揭秘ebay、亚马逊测评系统：从稳定环境搭建到防关联技术

在亚马逊、ebay平台上进行自养号测评、L ka等活动，首要问题是确保环境的安全性和稳定性。一个稳定的环境是进行测评的基础，如果无法解决安全性问题，那么从事这些项目就不值得。我们在环境技术研发领域已经有8年的经验，在早期测试了…
阅读更多...
连连看游戏页面网站源码，直接使用

连连看游戏页面网站源码，直接使用

可以上传自己喜欢的图片 游戏页面 通关页面 源码免费下载地址抄笔记 (chaobiji.cn)
阅读更多...
信号分解 | VMD(变分模态分解)-Matlab

信号分解 | VMD(变分模态分解)-Matlab

分解效果 VMD(变分模态分解) 变分模态分解（Variational Mode Decomposition，VMD）是一种信号分解方法，用于将非平稳信号分解为一组模态函数。VMD是一种自适应的数据驱动方法，可以有效地处理具有非线性和非平稳特性的信号。 VMD的基本思想是通过迭代优化过程，将原始信号分…
阅读更多...
4.16学习总结

4.16学习总结

MySQL数据库学习(一) 一.MySQL数据库的基本知识 (一).数据库 概念：数据仓库,软件,安装在操作系统之上 作用：存储数据，管理数据 (二).数据库的分类 关系型数据库：SQL（Structured Query Language） MySQL…
阅读更多...
创建k8s deploy yaml文件的imagePullSecrets语句

创建k8s deploy yaml文件的imagePullSecrets语句

镜像仓库是harbor kubectl create secret docker-registry key --docker-server192.168.0.190 --docker-usernameadmin --docker-passwordHarbor12345
阅读更多...
Fluke ADPT连接器(隔离版)----发布1

Fluke ADPT连接器(隔离版)----发布1

代替手工记录、记录后在整理的麻烦，轻点鼠标（单次采集、自动时间间隔采集自由选择）即可完成，测试数据导出图片、导出数据到EXCEL文件随意选择； 所需设备： 1、Fluke ADPT连接器；内附链接 主要…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站