Transformer结构详解(有图,有细节)

2024-02-02 11:32

本文主要是介绍Transformer结构详解(有图,有细节),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

文章目录

  • 1. transformer的基本结构
  • 2. 模块详解
    • 2.1 模块1:Positional Embedding
    • 2.2 模块2:Multi-Head Attention
      • 2.2.1 Scaled Dot-Product Attention
      • 2.2.2 Multi-Head
    • 2.3 模块3:ADD
    • 2.4 模块4:Layer Normalization
    • 2.5 模块5:Feed Forward NetWork
    • 2.6 模块6:Masked Multi-Head Attention
    • 2.7 模块7: Multi-Head Attention
    • 2.8 模块8:Linear
    • 2.9 模块9:SoftMax
  • 3. transformer在机器翻译任务中的使用
  • 4 transformer 相关的其它问题

 

1. transformer的基本结构

在这里插入图片描述

2. 模块详解

2.1 模块1:Positional Embedding

  P E PEPE模块的主要做用是把位置信息加入到输入向量中,使模型知道每个字的位置信息。对于每个位置的P E PEPE是固定的,不会因为输入的句子不同而不同,且每个位置的P E PEPE大小为1 ∗ n 1 *n1∗n(n为word embedding 的dim size),transformer中使用正余弦波来计算P E PEPE,具体如下:
P E ( p o s , 2 i ) = s i n ( p o s / 1000 0 2 i / d m o d e l ) P E ( p o s , 2 i + 1 ) = c o s ( p o s / 1000 0 2 i / d m o d e l ) PE_{(pos,2i)} = sin(pos/10000^{2i/d_{model}}) \\ PE_{(pos,2i+1)} = cos(pos/10000^{2i/d_{model}})PE(pos,2i)​=sin(pos/100002i/dmodel​)PE(pos,2i+1)​=cos(pos/100002i/dmodel​)

  • p o s pospos代表的是一个字在句子中的位置,从0到名字长度减1,是下图中红色的序号。
  • i ii代表的是dim 的序号,是下图中蓝色的序号:
    • 当i ii为偶数时,此位置的值使用 s i n ( p o s / 1000 0 2 i / d m o d e l ) sin(pos/10000^{2i/d_{model}})sin(pos/100002i/dmodel​)来填充。
    • 当i ii为奇数时,些位置的值使用 c o s ( p o s / 1000 0 2 i / d m o d e l ) cos(pos/10000^{2i/d_{model}})cos(pos/100002i/dmodel​)来填充
      在这里插入图片描述
      实现代码:
class PositionalEncoding(nn.Module):"Implement the PE function."def __init__(self, d_model, dropout, max_len=5000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(p=dropout)# Compute the positional encodings once in log space.pe = torch.zeros(max_len, d_model).float()position = torch.arange(0, max_len).unsqueeze(1).float()div_term = torch.exp(torch.arange(0, d_model, 2).float() *-(math.log(10000.0) / d_model)).float()pe[:, 0::2] = torch.sin(position * div_term)pe[:, 1::2] = torch.cos(position * div_term)pe = pe.unsqueeze(0)self.register_buffer('pe', pe)def forward(self, x):x = x + Variable(self.pe[:, :x.size(1)],requires_grad=False)return self.dropout(x)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

至于为什么选择这种方式,论文中给出的解释是:

  1. 我们之所以选择这个函数,是因为我们假设它可以让模型很容易地通过相对位置来学习,因为对任意确定的偏移k kk, P E p o s + k PE_{pos+k}PEpos+k​可以表示为P E p o s PE_{pos}PEpos​的线性函数。
    理解:
    由s i n ( α + β ) = s i n α c o s β + s i n β c o s α c o s ( α + β ) = c o s α c o s β − s i n β s i n α sin(\alpha+\beta)=sin\alpha cos\beta + sin\beta cos\alpha\\ cos(\alpha+\beta)=cos\alpha cos\beta - sin\beta sin\alphasin(α+β)=sinαcosβ+sinβcosαcos(α+β)=cosαcosβ−sinβsinα
    推出:
    P E ( p o s + k , 2 i ) = s i n ( ( p o s + k ) / 1000 0 2 i / d m o d e l ) = s i n ( p o s / 1000 0 2 i / d m o d e l ) c o s ( k / 1000 0 2 i / d m o d e l ) + s i n ( p o s / 1000 0 2 i / d m o d e l ) c o s ( k / 1000 0 2 i / d m o d e l ) = P E ( p o s , 2 i ) P E ( k , 2 i + 1 ) − P E ( p o s , 2 i + 1 ) P E ( k , 2 i )

    PE(pos+k,2i)=sin((pos+k)/100002i/dmodel)=sin(pos/100002i/dmodel)cos(k/100002i/dmodel)+sin(pos/100002i/dmodel)cos(k/100002i/dmodel)=PE(pos,2i)PE(k,2i+1)−PE(pos,2i+1)PE(k,2i)PE(pos+k,2i)=sin((pos+k)/100002i/dmodel)=sin(pos/100002i/dmodel)cos(k/100002i/dmodel)+sin(pos/100002i/dmodel)cos(k/100002i/dmodel)=PE(pos,2i)PE(k,2i+1)−PE(pos,2i+1)PE(k,2i)

    PE(pos+k,2i)​=sin((pos+k)/100002i/dmodel​)=sin(pos/100002i/dmodel​)cos(k/100002i/dmodel​)+sin(pos/100002i/dmodel​)cos(k/100002i/dmodel​)=PE(pos,2i)PE(k,2i+1)−PE(pos,2i+1)PE(k,2i)​
    P E ( p o s + k , 2 i + 1 ) = c o s ( ( p o s + k ) / 1000 0 2 i / d m o d e l ) = c o s ( p o s / 1000 0 2 i / d m o d e l ) c o s ( k / 1000 0 2 i / d m o d e l ) − s i n ( p o s / 1000 0 2 i / d m o d e l ) s i n ( k / 1000 0 2 i / d m o d e l ) = P E ( p o s , 2 i + 1 ) P E ( k , 2 i + 1 ) − P E ( p o s , 2 i ) P E ( k , 2 i )

    PE(pos+k,2i+1)=cos((pos+k)/100002i/dmodel)=cos(pos/100002i/dmodel)cos(k/100002i/dmodel)−sin(pos/100002i/dmodel)sin(k/100002i/dmodel)=PE(pos,2i+1)PE(k,2i+1)−PE(pos,2i)PE(k,2i)PE(pos+k,2i+1)=cos((pos+k)/100002i/dmodel)=cos(pos/100002i/dmodel)cos(k/100002i/dmodel)−sin(pos/100002i/dmodel)sin(k/100002i/dmodel)=PE(pos,2i+1)PE(k,2i+1)−PE(pos,2i)PE(k,2i)

    PE(pos+k,2i+1)​=cos((pos+k)/100002i/dmodel​)=cos(pos/100002i/dmodel​)cos(k/100002i/dmodel​)−sin(pos/100002i/dmodel​)sin(k/100002i/dmodel​)=PE(pos,2i+1)PE(k,2i+1)−PE(pos,2i)PE(k,2i)​
    以P E ( p o s + k , 2 i ) = P E ( p o s , 2 i ) P E ( k , 2 i + 1 ) − P E ( p o s , 2 i + 1 ) P E ( k , 2 i ) PE(pos+k,2i)=PE(pos,2i)PE(k,2i+1)-PE(pos,2i+1)PE(k,2i)PE(pos+k,2i)=PE(pos,2i)PE(k,2i+1)−PE(pos,2i+1)PE(k,2i)为例,当k kk确定时: P E ( k , 2 i + 1 ) PE(k,2i+1)PE(k,2i+1)、P E ( k , 2 i ) PE(k,2i)PE(k,2i)均为常数,P E ( p o s + k , 2 i ) = P E ( p o s , 2 i ) ∗ 常 数 2 i + 1 k − P E ( p o s , 2 i + 1 ) ∗ 常 数 i k PE(pos+k,2i)=PE(pos,2i) * 常数_{2i+1}^k - PE(pos,2i+1) * 常数_{i}^kPE(pos+k,2i)=PE(pos,2i)∗常数2i+1k​−PE(pos,2i+1)∗常数ik​
    上式为即为1)中所说的线性函数。我们知道,每个位置(pos)的PE值均不同,因此我们可以根据PE的值区分位置,而由上面的线性函数,我们可以计量出两个位置的相对距离
  2. 我们还尝试使用预先学习的positional embeddings 来代替正弦波,发现这两个版本产生了几乎相同的结果 。我们之所以选择正弦曲线,是因为它允许模型扩展到比训练中遇到的序列长度更长的序列。
    理解:
      第二点很好理解就是说了下正弦波的优点。这里我着重讲下正弦波存在的问题。在transformer架构里,我们计算两个特征的关系用的是点积的的方式(因为使用了Dot-Product Attention)。所以两个PE的关系(距离)实际是以它们的点积来表示的。举例如下[ 1 ] ^{[1]}[1]:
    我们令c i = 1 / 1000 0 2 i / d m o d e l c_i=1/10000^{2i/d_{model}}ci​=1/100002i/dmodel​,则第t tt及t + 1 t+1t+1个位置的positional embedding 是:
    P E t = [ s i n ( c 0 t ) c o s ( c 0 t ) s i n ( c 1 t ) c o s ( c 1 t ) ⋮ s i n ( c d 2 − 1 t ) c o s ( c d 2 − 1 t ) ] T PE_t={\left[ {

    sin(c0t)cos(c0t)sin(c1t)cos(c1t)⋮sin(cd2−1t)cos(cd2−1t)sin(c0t)cos(c0t)sin(c1t)cos(c1t)⋮sin(cd2−1t)cos(cd2−1t)

    } \right]^T}PEt​=⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡​sin(c0​t)cos(c0​t)sin(c1​t)cos(c1​t)⋮sin(c2d​−1​t)cos(c2d​−1​t)​⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤​T
    P E t + k = [ s i n ( c 0 ( t + k ) ) c o s ( c 0 ( t + k ) ) s i n ( c 1 ( t + k ) ) c o s ( c 1 ( t + k ) ) ⋮ s i n ( c d 2 − 1 ( t + k ) ) c o s ( c d 2 − 1 ( t + k ) ) ] T PE_{t+k}={\left[ {

    sin(c0(t+k))cos(c0(t+k))sin(c1(t+k))cos(c1(t+k))⋮sin(cd2−1(t+k))cos(cd2−1(t+k))sin(c0(t+k))cos(c0(t+k))sin(c1(t+k))cos(c1(t+k))⋮sin(cd2−1(t+k))cos(cd2−1(t+k))

    } \right]^T}PEt+k​=⎣⎢⎢⎢⎢⎢⎢⎢⎢⎢⎡​sin(c0​(t+k))cos(c0​(t+k))sin(c1​(t+k))cos(c1​(t+k))⋮sin(c2d​−1​(t+k))cos(c2d​−1​(t+k))​⎦⎥⎥⎥⎥⎥⎥⎥⎥⎥⎤​T
    则:P E t P E t + k = Σ j = 0 d 2 [ s i n ( c j t ) s i n ( c j ( t + k ) + c o s ( c j t ) c o s ( c j ( t + k ) ] = Σ j = 0 d 2 c o s ( c j ( t − ( t + k ) ) = Σ j = 0 d 2 c o s ( c j k )

    PEtPEt+k=Σd2j=0[sin(cjt)sin(cj(t+k)+cos(cjt)cos(cj(t+k)]=Σd2j=0cos(cj(t−(t+k))=Σd2j=0cos(cjk)PEtPEt+k=Σj=0d2[sin(cjt)sin(cj(t+k)+cos(cjt)cos(cj(t+k)]=Σj=0d2cos(cj(t−(t+k))=Σj=0d2cos(cjk)

    PEt​PEt+k​​=Σj=02d​​[sin(cj​t)sin(cj​(t+k)+cos(cj​t)cos(cj​(t+k)]=Σj=02d​​cos(cj​(t−(t+k))=Σj=02d​​cos(cj​k)​
      上式的第二行是使用了 c o s ( α − β ) = s i n α s i n β + c o s α c o s β cos(\alpha-\beta)=sin\alpha sin\beta + cos\alpha cos\betacos(α−β)=sinαsinβ+cosαcosβ 这个公式进行的变换。从最终的结果我们可以看出,两个embedding的距离度量只与间隔k kk有关,而c o s coscos函数关于y轴对称,即c o s x = c o s ( − x ) cosx=cos(-x)cosx=cos(−x),所以,P E t P E t + k PE_tPE_{t+k}PEt​PEt+k​的度量只与k kk的大小有关,与谁在前,谁在后无关。即,经过dot-attention机制后,我们把positional embedding中的顺序信息丢失了。所以,从这方面看,正弦波这种位置PE并不太适合在用在transformer结构中,这也可能是后面的bert,t5都采用的基于学习的positional embedding。(注:模块3会把顺序信息传递下去,但我们还是在算法的核心处理上丢失了信息。)

2.2 模块2:Multi-Head Attention

  这个模块是transformer的核心,我们把这块拆成两部分来理解,先讲下其中的Scaled Dot-Product Attention(缩放的点积注意力机制),再讲Multi-Head。

2.2.1 Scaled Dot-Product Attention

  我们先看下论文中的 Scaled Dot-Product Attention 步骤,如下图:
在这里插入图片描述
下面我们对着上面的图讲一下,具体的看下每步做了什么。

  1. 首先说下Q,K,V,在transformer的encoder中,输入只有一个,即输入向量与位置向量的和,我们暂且叫做input_sum。Q,K,V就是这个input_sum通过三个linear层映射而来。如下图
    在这里插入图片描述

由于linear的输入和输出均为d m o d e l d_{model}dmodel​,所以Q,K,V的大小和input_sum的大小是一致的。

  1. MatMul: 这步是实际是计算的 Q ∗ K T Q*K^TQ∗KT, 如下图:
    在这里插入图片描述
    从上图可以看出Q ∗ K T Q*K^TQ∗KT的结果s c o r e s scoresscores是一个L ∗ L L*LL∗L的矩阵(L为句字长度),其中scores中的[ i , j ] [i,j][i,j]位置表示的是Q QQ中的第i ii行的字和K T K^TKT中第j jj列的相似度(也可以说是重要度,我们可以这么理解,在机器翻译任务中,当我们翻译一句话的第i ii个字的的时候,我们要考虑原文中哪个位置的字对我们现在要翻译的这个位置的字的影响最大)。

  2. Scale :这部分就是对上面的s c o r e s scoresscores进行了个类似正则化的操作。
    s c o r e s = s c o r e s d q scores=\frac{scores}{\sqrt{d_q}}scores=dq​​scores​ (这里要说一下d q d_{q}dq​,论文中给出的是d h d_{h}dh​,即d m o d e l / h d_{model}/hdmodel​/h, 因为论文中做了multi-head,所以 d q = d h d_q=d_{h}dq​=dh​),这里解释下除以d q \sqrt{d_q}dq​​的原因,原文是这样说的:“我们认为对于大的d k d_kdk​,点积在数量级上增长的幅度大,将softmax函数推向具有极小梯度的区域4 ^44。为了抵消这种影响,我们对点积扩展1 d k \frac{1}{\sqrt{d_k}}dk​​1​倍”。

  3. Mask: 这步使用一个很小的值,对指定位置进行覆盖填充。这样,在之后计算softmax时,由于我们填充的值很小,所以计算出的概率也会很小,基本就忽略了。(如果不填个很小的值的话,后面我们计算softmax时,e x i ∑ i = 1 k e x i \frac{e^{x_i}}{\sum_{i=1}^{k}{e^{x_i}}}∑i=1k​exi​exi​​ ,当x = 0 x=0x=0时(padding的值),分子e 0 = 1 e^{0}=1e0=1这可不是一个很小的值。),mask操作在encoder和decoder过程中都存在,在encoder中我们是对padding的值进行mask,在decoder中我们主要是为了不让前面的词在翻译时看到未来的词,所以对当前词之后的词的信息进行mask。下面我们先看看encoder中关于padding的mask是怎么做的。
    在这里插入图片描述
      如上图,输入中有两个pad字符,s c o r e s scoresscores中的x都是pad参与计算产生的,我们为了排除pad产生的影响,我们提供了如图的mask,我们把scores与mask的位置一一对应,如果mask的值为0,则scores的对应位置填充一个非常小的负数(例如:− e 9 -e^9−e9)。最终得到的是上图最后一个表格。说了这么多,其实在pytorch中就一句话。

scores = scores.masked_fill(mask == 0, -1e9)
  • 1
  1. SoftMax: 对scores中的数据按行做softmax。这样就把权得转换成了概率。
    在这里插入图片描述
  2. MatMul: 这步就是使用softmax后的概率值与V VV矩阵做矩阵乘法。
    在这里插入图片描述
    附上代码:
def attention(query, key, value, mask=None):d_k = query.size(-1)scores = torch.matmul(query, key.transpose(-2, -1)) \/ math.sqrt(d_k)if mask is not None:scores = scores.masked_fill(mask == 0, -1e9)p_attn = F.softmax(scores, dim = -1)return torch.matmul(p_attn, value)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

2.2.2 Multi-Head

  这里我们看看multi-head attention中的 multi-head是什么意思。我们假设d m o d e l = 512 d_{model}=512dmodel​=512,h = 8 h=8h=8(8个头),说下transformer中是怎么处理的:
  前面我们说过了,Q QQ、K KK、V VV三个矩阵是encoder的输入经过三个linear映射而成,它们的大小是[ B , L , D ] [B,L,D][B,L,D](batch size, max sentence length, embedding size), 这里为了说的清楚些,我们暂时不看[ B ] [B][B]这个维度。那么Q QQ、K KK、V VV的维度都为[ L , D ] [L,D][L,D],multi-head就是在[ D ] [D][D]维度上对数据进行切割,把数据切成等长的8段(h = 8 h=8h=8),这样Q QQ、K KK、V VV均被切成等长的8段,然后对应的Q QQ、K KK、V VV子段组成一组,每组通过 Scaled Dot-Product Attention 算法 计算出结果,这样的结果我们会得到8个,然后把这8个结果再拼成一个结果,就multi-head的结果。具体过程如下图:

在这里插入图片描述

2.3 模块3:ADD

  此模块做了个类似残差的操作,不同的是不是用输入减去输出,而是用输入加上输出。(指Multi-Head Attention模块的输入和输出),具体操作就是把模块2的输入矩阵与模块2的输入矩阵的对应位置做加法运算。

2.4 模块4:Layer Normalization

  不论是layer normalization还是batch normalization,其实做的都是一件事情,都是根据 x = a ∗ x − x ‾ s t d + e p s + b x = a * \frac{x - \overline{x}}{std + eps} + bx=a∗std+epsx−x​+b对x xx的分布进行调整。不同的是x ‾ \overline{x}x和s t d stdstd的计算方式不同。如下图:
在这里插入图片描述
  batch normalization的x ‾ \overline{x}x和s t d stdstd是延粉色方向计算的,而layer normalization是延蓝色方向计算的。如果兄弟们去面试,可能面试官会问为什么这里没有使用BN,而使用了LN,我的理解是,BN对batch size的大小是有要求的,一般batch size越大,计算出的x ‾ \overline{x}x越好,而我用12G内存的GPU,跑transformer的模型时,batch size最多也就设置到32。batch size还是偏小的。所以使用与batch size无关的layer normlization。从另一个角度讲,batch size之所以小,是因为我们的embedding size 大,而layer normalization 正好是延这个方向做的,所以正好使得layer normalization计算的更稳定。

2.5 模块5:Feed Forward NetWork

  Feed Forward NetWork 翻译成中文叫 前馈网络,其实就是MLP。我们这里不纠结于FFN的定义,我们直接看下transformer里是怎么实现的。如下图,我们先把输入向量从512维(d m o d e l d_{model}dmodel​)映射到2048维,然后再映射到512维。实现时,就是使用两个linear层,第一个linear的输入是512维,输出是2048维,第二个linear的输入是2048,输出是512。
在这里插入图片描述

2.6 模块6:Masked Multi-Head Attention

  上文已讲了Multi-Head Attention,而且在讲 Scaled Dot-Product Attention 时也讲了mask机制,此模块的区别在于maked的策略不同,在encoder中我们是把padding给masked掉,这里我们除了要考虑padding,还要考虑预测时的未来变量问题,换句话说,我们是用一句话中的前N − 1 N-1N−1个字预测第N NN个字,那么我们在预测第N NN个字时,就不能让模型看到第N个字之后的信息,所以这里们把预测第N NN个字时,第N NN(包括)个字之后的字都masked掉。我们假设预测序列为’i like this apple’,则我们要做如下的mask。
在这里插入图片描述

2.7 模块7: Multi-Head Attention

  模块7 与上文 模块2(encoder 中 的 Multi-Head Attention) 代码实现上完全相同,区别再于模块2 只有一个输入,模块2把此输入经过三个linear映射成Q QQ、K KK、V VV , 而模块7的输入有两个,一个是decoder的输入经过第一个大模块传过来的值(为了方便,我们叫它input_x),一个是encoder最终结果(我们暂叫它input_memory), 模块7是把input_x通过一个linear映射成了Q QQ,然后通过两个linear把input_memory映射成K KK、V VV ,其它的与模块2完全一致。

2.8 模块8:Linear

  此模块的目的是把模型的输transformer decoder的输出从d m o d e l d_{model}dmodel​维度映射到词表大小的维度。linear本身也比较简单,这里不再细讲了。
在这里插入图片描述

2.9 模块9:SoftMax

  此模块会把上层linear的输出转化成概率,对应到某个字的概率。

3. transformer在机器翻译任务中的使用

  在《Attention is All You Need》这篇文章中,是把transformer做为一个特征提取器放在一个Encoder-Decoder(下文用Encoder-Stack和Decoder-Stack,用以和transformer的encoder, decoder区分)架构中的,具体细节见下图:

在这里插入图片描述

  上面的图片把整个结构基本都画出来了,这里再说下训练时的数据走向及流程:
1) 数据X XX 输入到Encoder-Stack中,得到输出变量e n c o d e r _ o u t p u t encoder\_outputencoder_output
2) e n c o d e r _ o u t p u t encoder\_outputencoder_output 做为K e y KeyKey和V a l u e ValueValue的原始输入 输入到Decoder-Stack中,Decoder-Stack的Query为上一轮Decoder-Stack的输出。
具体流程见下图:
在这里插入图片描述

  这里我提一下decoder stack的输入(上图中的Query),前面说过了,在transformer中,decoder的核心思想是用一个句子中的前N − 1 N-1N−1个字,预测第N NN个字,但在预测第一个字的时候,前面没有字,这时我们可以在每句话前面加上一个固定的开始标志(bos), 这样相当于把整个句子右移了一位。

4 transformer 相关的其它问题

  这部分我是想写写transformer的并行等其它问题,但今天写的太累了,主要的也都写完了,就先发了。

References
[ 1 ] [1][1] https://zhuanlan.zhihu.com/p/166244505

这篇关于Transformer结构详解(有图,有细节)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/670565

相关文章

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

OpenHarmony鸿蒙开发( Beta5.0)无感配网详解

1、简介 无感配网是指在设备联网过程中无需输入热点相关账号信息,即可快速实现设备配网,是一种兼顾高效性、可靠性和安全性的配网方式。 2、配网原理 2.1 通信原理 手机和智能设备之间的信息传递,利用特有的NAN协议实现。利用手机和智能设备之间的WiFi 感知订阅、发布能力,实现了数字管家应用和设备之间的发现。在完成设备间的认证和响应后,即可发送相关配网数据。同时还支持与常规Sof

usaco 1.3 Mixing Milk (结构体排序 qsort) and hdu 2020(sort)

到了这题学会了结构体排序 于是回去修改了 1.2 milking cows 的算法~ 结构体排序核心: 1.结构体定义 struct Milk{int price;int milks;}milk[5000]; 2.自定义的比较函数,若返回值为正,qsort 函数判定a>b ;为负,a<b;为0,a==b; int milkcmp(const void *va,c

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

K8S(Kubernetes)开源的容器编排平台安装步骤详解

K8S(Kubernetes)是一个开源的容器编排平台,用于自动化部署、扩展和管理容器化应用程序。以下是K8S容器编排平台的安装步骤、使用方式及特点的概述: 安装步骤: 安装Docker:K8S需要基于Docker来运行容器化应用程序。首先要在所有节点上安装Docker引擎。 安装Kubernetes Master:在集群中选择一台主机作为Master节点,安装K8S的控制平面组件,如AP

自定义类型:结构体(续)

目录 一. 结构体的内存对齐 1.1 为什么存在内存对齐? 1.2 修改默认对齐数 二. 结构体传参 三. 结构体实现位段 一. 结构体的内存对齐 在前面的文章里我们已经讲过一部分的内存对齐的知识,并举出了两个例子,我们再举出两个例子继续说明: struct S3{double a;int b;char c;};int mian(){printf("%zd\n",s

嵌入式Openharmony系统构建与启动详解

大家好,今天主要给大家分享一下,如何构建Openharmony子系统以及系统的启动过程分解。 第一:OpenHarmony系统构建      首先熟悉一下,构建系统是一种自动化处理工具的集合,通过将源代码文件进行一系列处理,最终生成和用户可以使用的目标文件。这里的目标文件包括静态链接库文件、动态链接库文件、可执行文件、脚本文件、配置文件等。      我们在编写hellowor

LabVIEW FIFO详解

在LabVIEW的FPGA开发中,FIFO(先入先出队列)是常用的数据传输机制。通过配置FIFO的属性,工程师可以在FPGA和主机之间,或不同FPGA VIs之间进行高效的数据传输。根据具体需求,FIFO有多种类型与实现方式,包括目标范围内FIFO(Target-Scoped)、DMA FIFO以及点对点流(Peer-to-Peer)。 FIFO类型 **目标范围FIFO(Target-Sc

019、JOptionPane类的常用静态方法详解

目录 JOptionPane类的常用静态方法详解 1. showInputDialog()方法 1.1基本用法 1.2带有默认值的输入框 1.3带有选项的输入对话框 1.4自定义图标的输入对话框 2. showConfirmDialog()方法 2.1基本用法 2.2自定义按钮和图标 2.3带有自定义组件的确认对话框 3. showMessageDialog()方法 3.1

脏页的标记方式详解

脏页的标记方式 一、引言 在数据库系统中,脏页是指那些被修改过但还未写入磁盘的数据页。为了有效地管理这些脏页并确保数据的一致性,数据库需要对脏页进行标记。了解脏页的标记方式对于理解数据库的内部工作机制和优化性能至关重要。 二、脏页产生的过程 当数据库中的数据被修改时,这些修改首先会在内存中的缓冲池(Buffer Pool)中进行。例如,执行一条 UPDATE 语句修改了某一行数据,对应的缓