一步步解析Attention is All You Need
本文将通过细节剖析以及代码相结合的方式,来一步步解析Attention is all you need这篇文章。
这篇文章的下载地址为:https://arxiv.org/abs/1706.03762
本文的部分图片来自文章:https://mp.weixin.qq.com/s/RLxWevVWHXgX-UcoxDS70w,写的非常好!
本文边讲细节边配合代码实战,代码地址为:https://github.com/princewen/tensorflow_practice/tree/master/basic/Basic-Transformer-Demo
数据地址为:https://pan.baidu.com/s/14XfprCqjmBKde9NmNZeCNg 密码:lfwu
好了,废话不多说,我们进入正题!我们从简单到复杂,一步步介绍该模型的结构!
1、整体架构
模型的整体框架如下:
整体架构看似复杂,其实就是一个Seq2Seq结构,简化一下,就是这样的:
Encoder的输出和decoder的结合如下,即最后一个encoder的输出将和每一层的decoder进行结合:
好了,我们主要关注的是每一层Encoder和每一层Decoder的内部结构。如下图所示:
可以看到,Encoder的每一层有两个操作,分别是Self-Attention和Feed Forward;而Decoder的每一层有三个操作,分别是Self-Attention、Encoder-Decoder Attention以及Feed Forward操作。这里的Self-Attention和Encoder-Decoder Attention都是用的是Multi-Head Attention机制,这也是我们本文重点讲解的地方。
在介绍之前,我们先介绍下我们的数据,经过处理之后,数据如下:
很简单,上面部分是我们的x,也就是encoder的输入,下面部分是y,也就是decoder的输入,这是一个机器翻译的数据,x中的每一个id代表一个语言中的单词id,y中的每一个id代表另一种语言中的单词id。后面为0的部分是填充部分,代表这个句子的长度没有达到我们设置的最大长度,进行补齐。
2、Position Embedding
给定我们的输入数据,我们首先要转换成对应的embedding,由于我们后面要在计算attention时屏蔽掉填充的部分,所以这里我们对于填充的部分的embedding直接赋予0值。Embedding的函数如下:
def embedding(inputs,vocab_size,num_units,zero_pad=True,scale=True,scope="embedding",reuse=None):with tf.variable_scope(scope, reuse=reuse):lookup_table = tf.get_variable('lookup_table',dtype=tf.float32,shape=[vocab_size, num_units],initializer=tf.contrib.layers.xavier_initializer())if zero_pad:lookup_table = tf.concat((tf.zeros(shape=[1, num_units]),lookup_table[1:, :]), 0)outputs = tf.nn.embedding_lookup(lookup_table, inputs)if scale:outputs = outputs * (num_units ** 0.5)return outputs
在本文中,Embedding操作不是普通的Embedding而是加入了位置信息的Embedding,我们称之为Position Embedding。因为在本文的模型中,已经没有了循环神经网络这样的结构,因此序列信息已经无法捕捉。但是序列信息非常重要,代表着全局的结构,因此必须将序列的分词相对或者绝对position信息利用起来。位置信息的计算公式如下
其中pos代表的是第几个词,i代表embedding中的第几维。这部分的代码如下,对于padding的部分,我们还是使用全0处理。
def positional_encoding(inputs,num_units,zero_pad = True,scale = True,scope = "positional_encoding",reuse=None):N,T = inputs.get_shape().as_list()with tf.variable_scope(scope,reuse=True):position_ind = tf.tile(tf.expand_dims(tf.range(T),0),[N,1])position_enc = np.array([[pos / np.power(10000, 2.*i / num_units) for i in range(num_units)]for pos in range(T)])position_enc[:,0::2] = np.sin(position_enc[:,0::2]) # dim 2iposition_enc[:,1::2] = np.cos(position_enc[:,1::2]) # dim 2i+1lookup_table = tf.convert_to_tensor(position_enc)if zero_pad:lookup_table = tf.concat((tf.zeros(shape=[1,num_units]),lookup_table[1:,:]),0)outputs = tf.nn.embedding_lookup(lookup_table,position_ind)if scale:outputs = outputs * num_units ** 0.5return outputs
所以对于输入,我们调用上面两个函数,并将结果相加就能得到最终Position Embedding的结果:
self.enc = embedding(self.x,vocab_size=len(de2idx),num_units = hp.hidden_units,zero_pad=True, # 让padding一直是0scale=True,scope="enc_embed")
self.enc += embedding(tf.tile(tf.expand_dims(tf.range(tf.shape(self.x)[1]),0),[tf.shape(self.x)[0],1]),vocab_size = hp.maxlen,num_units = hp.hidden_units,zero_pad = False,scale = False,scope = "enc_pe")
3、Multi-Head Attention
3.1 Attention简单回顾
Attention其实就是计算一种相关程度,看下面的例子:
Attention通常可以进行如下描述,表示为将query(Q)和key-value pairs映射到输出上,其中query、每个key、每个value都是向量,输出是V中所有values的加权,其中权重是由Query和每个key计算出来的,计算方法分为三步:
1)计算比较Q和K的相似度,用f来表示:
2)将得到的相似度进行softmax归一化:
3)针对计算出来的权重,对所有的values进行加权求和,得到Attention向量:
计算相似度的方法有以下4种:
在本文中,我们计算相似度的方式是第一种,本文提出的Attention机制称为Multi-Head Attention,不过在这之前,我们要先介绍它的简单版本 Scaled Dot-Product Attention。
计算Attention首先要有query,key和value。我们前面提到了,Encoder的attention是self-attention,Decoder里面的attention首先是self-attention,然后是encoder-decoder attention。这里的两种attention是针对query和key-value来说的,对于self-attention来说,计算得到query和key-value的过程都是使用的同样的输入,因为要算自己跟自己的attention嘛;而对encoder-decoder attention来说,query的计算使用的是decoder的输入,而key-value的计算使用的是encoder的输出,因为我们要计算decoder的输入跟encoder里面每一个的相似度嘛。
因此本文下面对于attention的讲解,都是基于self-attention来说的,如果是encoder-decoder attention,只要改一下输入即可,其余过程都是一样的。
3.2 Scaled Dot-Product Attention
Scaled Dot-Product Attention的图示如下:
接下来,我们对上述过程进行一步步的拆解:
First Step-得到embedding
给定我们的输入数据,我们首先要转换成对应的position embedding,效果图如下,绿色部分代表填充部分,全0值:
得到Embedding的过程我们上文中已经介绍过了,这里不再赘述。
Second Step-得到Q,K,V
计算Attention首先要有Query,Key和Value,我们通过一个线性变换来得到三者。我们的输入是position embedding,过程如下:
代码也很简单,下面的代码中,如果是self-attention的话,query和key-value输入的embedding是一样的。padding的部分由于都是0,结果中该部分还是0,所以仍然用绿色表示
# Linear projection
Q = tf.layers.dense(queries,num_units,activation=tf.nn.relu) #
K = tf.layers.dense(keys,num_units,activation=tf.nn.relu) #
V = tf.layers.dense(keys,num_units,activation=tf.nn.relu) #
Third-Step-计算相似度
接下来就是计算相似度了,我们之前说过了,本文中使用的是点乘的方式,所以将Q和K进行点乘即可,过程如下:
文中对于相似度还除以了dk的平方根,这里dk是key的embedding长度。
这一部分的代码如下:
outputs = tf.matmul(Q,tf.transpose(K,[0,2,1]))
outputs = outputs / (K.get_shape().as_list()[-1] ** 0.5)
你可能注意到了,这样做其实是得到了一个注意力的矩阵,每一行都是一个query和所有key的相似性,对self-attention来说,其效果如下:
不过我们还没有进行softmax归一化操作,因为我们还需要进行一些处理。
Forth-Step-增加mask
刚刚得到的注意力矩阵,我们还需要做一下处理,主要有:
- query和key有些部分是填充的,这些需要用mask屏蔽,一个简单的方法就是赋予一个很小很小的值或者直接变为0值。
- 对于decoder的来说,我们是不能看到未来的信息的,所以对于decoder的输入,我们只能计算它和它之前输入的信息的相似度。
我们首先对key中填充的部分进行屏蔽,我们之前介绍了,在进行embedding时,填充的部分的embedding 直接设置为全0,所以我们直接根据这个来进行屏蔽,即对embedding的向量所有维度相加得到一个标量,如果标量是0,那就代表是填充的部分,否则不是:
这部分的代码如下:
key_masks = tf.sign(tf.abs(tf.reduce_sum(keys,axis=-1)))
key_masks = tf.tile(tf.expand_dims(key_masks,1),[1,tf.shape(queries)[1],1])
paddings = tf.ones_like(outputs) * (-2 ** 32 + 1)
outputs = tf.where(tf.equal(key_masks,0),paddings,outputs)
经过这一步处理,效果如下,我们下图中用深灰色代表屏蔽掉的部分:
接下来的操作只针对Decoder的self-attention来说,我们首先得到一个下三角矩阵,这个矩阵主对角线以及下方的部分是1,其余部分是0,然后根据1或者0来选择使用output还是很小的数进行填充:
diag_vals = tf.ones_like(outputs[0,:,:])
tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense()
masks = tf.tile(tf.expand_dims(tril,0),[tf.shape(outputs)[0],1,1])paddings = tf.ones_like(masks) * (-2 ** 32 + 1)
outputs = tf.where(tf.equal(masks,0),paddings,outputs)
得到的效果如下图所示:
接下来,我们对query的部分进行屏蔽,与屏蔽key的思路大致相同,不过我们这里不是用很小的值替换了,而是直接把填充的部分变为0:
query_masks = tf.sign(tf.abs(tf.reduce_sum(queries,axis=-1)))
query_masks = tf.tile(tf.expand_dims(query_masks,-1),[1,1,tf.shape(keys)[1]])
outputs *= query_masks
经过这一步,Encoder和Decoder得到的最终的相似度矩阵如下,上边是Encoder的结果,下边是Decoder的结果:
接下来,我们就可以进行softmax操作了:
outputs = tf.nn.softmax(outputs)
Fifth-Step-得到最终结果
得到了Attention的相似度矩阵,我们就可以和Value进行相乘,得到经过attention加权的结果:
这一部分是一个简单的矩阵相乘运算,代码如下:
outputs = tf.matmul(outputs,V)
不过这并不是最终的结果,这里文中还加入了残差网络的结构,即将最终的结果和queries的输入进行相加:
outputs += queries
所以一个完整的Scaled Dot-Product Attention的代码如下:
def scaled_dotproduct_attention(queries,keys,num_units=None,num_heads = 0,dropout_rate = 0,is_training = True,causality = False,scope = "mulithead_attention",reuse = None):with tf.variable_scope(scope,reuse=reuse):if num_units is None:num_units = queries.get_shape().as_list[-1]# Linear projectionQ = tf.layers.dense(queries,num_units,activation=tf.nn.relu) #K = tf.layers.dense(keys,num_units,activation=tf.nn.relu) #V = tf.layers.dense(keys,num_units,activation=tf.nn.relu) #outputs = tf.matmul(Q,tf.transpose(K,[0,2,1]))outputs = outputs / (K.get_shape().as_list()[-1] ** 0.5)# 这里是对填充的部分进行一个mask,这些位置的attention score变为极小,我们的embedding操作中是有一个padding操作的,# 填充的部分其embedding都是0,加起来也是0,我们就会填充一个很小的数。key_masks = tf.sign(tf.abs(tf.reduce_sum(keys,axis=-1)))key_masks = tf.tile(tf.expand_dims(key_masks,1),[1,tf.shape(queries)[1],1])paddings = tf.ones_like(outputs) * (-2 ** 32 + 1)outputs = tf.where(tf.equal(key_masks,0),paddings,outputs)# 这里其实就是进行一个mask操作,不给模型看到未来的信息。if causality:diag_vals = tf.ones_like(outputs[0,:,:])tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense()masks = tf.tile(tf.expand_dims(tril,0),[tf.shape(outputs)[0],1,1])paddings = tf.ones_like(masks) * (-2 ** 32 + 1)outputs = tf.where(tf.equal(masks,0),paddings,outputs)outputs = tf.nn.softmax(outputs)# Query Maskquery_masks = tf.sign(tf.abs(tf.reduce_sum(queries,axis=-1)))query_masks = tf.tile(tf.expand_dims(query_masks,-1),[1,1,tf.shape(keys)[1]])outputs *= query_masks# Dropoutoutputs = tf.layers.dropout(outputs,rate = dropout_rate,training = tf.convert_to_tensor(is_training))# Weighted sumoutputs = tf.matmul(outputs,V)# Residual connectionoutputs += queries# Normalizeoutputs = normalize(outputs)return outputs
3.3 Multi-Head Attention
Multi-Head Attention就是把Scaled Dot-Product Attention的过程做H次,然后把输出合起来。论文中,它的结构图如下:
这部分的示意图如下所示,我们重复做3次相似的操作,得到每一个的结果矩阵,随后将结果矩阵进行拼接,再经过一次的线性操作,得到最终的结果:
Scaled Dot-Product Attention可以看作是只有一个Head的Multi-Head Attention,这部分的代码跟Scaled Dot-Product Attention大同小异,我们直接贴出:
def multihead_attention(queries,keys,num_units=None,num_heads = 0,dropout_rate = 0,is_training = True,causality = False,scope = "mulithead_attention",reuse = None):with tf.variable_scope(scope,reuse=reuse):if num_units is None:num_units = queries.get_shape().as_list[-1]# Linear projectionQ = tf.layers.dense(queries,num_units,activation=tf.nn.relu) #K = tf.layers.dense(keys,num_units,activation=tf.nn.relu) #V = tf.layers.dense(keys,num_units,activation=tf.nn.relu) ## Split and ConcatQ_ = tf.concat(tf.split(Q,num_heads,axis=2),axis=0) #K_ = tf.concat(tf.split(K,num_heads,axis=2),axis=0)V_ = tf.concat(tf.split(V,num_heads,axis=2),axis=0)outputs = tf.matmul(Q_,tf.transpose(K_,[0,2,1]))outputs = outputs / (K_.get_shape().as_list()[-1] ** 0.5)# 这里是对填充的部分进行一个mask,这些位置的attention score变为极小,我们的embedding操作中是有一个padding操作的,# 填充的部分其embedding都是0,加起来也是0,我们就会填充一个很小的数。key_masks = tf.sign(tf.abs(tf.reduce_sum(keys,axis=-1)))key_masks = tf.tile(key_masks,[num_heads,1])key_masks = tf.tile(tf.expand_dims(key_masks,1),[1,tf.shape(queries)[1],1])paddings = tf.ones_like(outputs) * (-2 ** 32 + 1)outputs = tf.where(tf.equal(key_masks,0),paddings,outputs)# 这里其实就是进行一个mask操作,不给模型看到未来的信息。if causality:diag_vals = tf.ones_like(outputs[0,:,:])tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense()masks = tf.tile(tf.expand_dims(tril,0),[tf.shape(outputs)[0],1,1])paddings = tf.ones_like(masks) * (-2 ** 32 + 1)outputs = tf.where(tf.equal(masks,0),paddings,outputs)outputs = tf.nn.softmax(outputs)# Query Maskquery_masks = tf.sign(tf.abs(tf.reduce_sum(queries,axis=-1)))query_masks = tf.tile(query_masks,[num_heads,1])query_masks = tf.tile(tf.expand_dims(query_masks,-1),[1,1,tf.shape(keys)[1]])outputs *= query_masks# Dropoutoutputs = tf.layers.dropout(outputs,rate = dropout_rate,training = tf.convert_to_tensor(is_training))# Weighted sumoutputs = tf.matmul(outputs,V_)# restore shapeoutputs = tf.concat(tf.split(outputs,num_heads,axis=0),axis=2)# Residual connectionoutputs += queries# Normalizeoutputs = normalize(outputs)return outputs
4、Position-wise Feed-forward Networks
在进行了Attention操作之后,encoder和decoder中的每一层都包含了一个全连接前向网络,对每个position的向量分别进行相同的操作,包括两个线性变换和一个ReLU激活输出:
代码如下:
def feedforward(inputs,num_units=[2048, 512],scope="multihead_attention",reuse=None):with tf.variable_scope(scope, reuse=reuse):# Inner layerparams = {"inputs": inputs, "filters": num_units[0], "kernel_size": 1,"activation": tf.nn.relu, "use_bias": True}outputs = tf.layers.conv1d(**params)# Readout layerparams = {"inputs": outputs, "filters": num_units[1], "kernel_size": 1,"activation": None, "use_bias": True}outputs = tf.layers.conv1d(**params)# Residual connectionoutputs += inputs# Normalizeoutputs = normalize(outputs)return outputs
5、Encoder的结构
Encoder有N(默认是6)层,每层包括两个sub-layers:
1 )第一个sub-layer是multi-head self-attention mechanism,用来计算输入的self-attention;
2 )第二个sub-layer是简单的全连接网络。
每一个sub-layer都模拟了残差网络的结构,其网络示意图如下:
根据我们刚才定义的函数,其完整的代码如下:
with tf.variable_scope("encoder"):# Embeddingself.enc = embedding(self.x,vocab_size=len(de2idx),num_units = hp.hidden_units,zero_pad=True, # 让padding一直是0scale=True,scope="enc_embed")## Positional Encodingif hp.sinusoid:self.enc += positional_encoding(self.x,num_units = hp.hidden_units,zero_pad = False,scale = False,scope='enc_pe')else:self.enc += embedding(tf.tile(tf.expand_dims(tf.range(tf.shape(self.x)[1]),0),[tf.shape(self.x)[0],1]),vocab_size = hp.maxlen,num_units = hp.hidden_units,zero_pad = False,scale = False,scope = "enc_pe")##Drop outself.enc = tf.layers.dropout(self.enc,rate = hp.dropout_rate,training = tf.convert_to_tensor(is_training))## Blocksfor i in range(hp.num_blocks):with tf.variable_scope("num_blocks_{}".format(i)):### MultiHead Attentionself.enc = multihead_attention(queries = self.enc,keys = self.enc,num_units = hp.hidden_units,num_heads = hp.num_heads,dropout_rate = hp.dropout_rate,is_training = is_training,causality = False)self.enc = feedforward(self.enc,num_units = [4 * hp.hidden_units,hp.hidden_units])
6、Decoder的结构
Decoder有N(默认是6)层,每层包括三个sub-layers:
1 )第一个是Masked multi-head self-attention,也是计算输入的self-attention,但是因为是生成过程,因此在时刻 i 的时候,大于 i 的时刻都没有结果,只有小于 i 的时刻有结果,因此需要做Mask.
2 )第二个sub-layer是对encoder的输入进行attention计算,这里仍然是multi-head的attention结构,只不过输入的分别是decoder的输入和encoder的输出。
3 )第三个sub-layer是全连接网络,与Encoder相同。
其网络示意图如下:
其代码如下:
with tf.variable_scope("decoder"):# Embeddingself.dec = embedding(self.decoder_inputs,vocab_size=len(en2idx),num_units = hp.hidden_units,scale=True,scope="dec_embed")## Positional Encodingif hp.sinusoid:self.dec += positional_encoding(self.decoder_inputs,vocab_size = hp.maxlen,num_units = hp.hidden_units,zero_pad = False,scale = False,scope = "dec_pe")else:self.dec += embedding(tf.tile(tf.expand_dims(tf.range(tf.shape(self.decoder_inputs)[1]), 0), [tf.shape(self.decoder_inputs)[0], 1]),vocab_size=hp.maxlen,num_units=hp.hidden_units,zero_pad=False,scale=False,scope="dec_pe")# Dropoutself.dec = tf.layers.dropout(self.dec,rate = hp.dropout_rate,training = tf.convert_to_tensor(is_training))## Blocksfor i in range(hp.num_blocks):with tf.variable_scope("num_blocks_{}".format(i)):## Multihead Attention ( self-attention)self.dec = multihead_attention(queries=self.dec,keys=self.dec,num_units=hp.hidden_units,num_heads=hp.num_heads,dropout_rate=hp.dropout_rate,is_training=is_training,causality=True,scope="self_attention")## Multihead Attention ( vanilla attention)self.dec = multihead_attention(queries=self.dec,keys=self.enc,num_units=hp.hidden_units,num_heads=hp.num_heads,dropout_rate=hp.dropout_rate,is_training=is_training,causality=False,scope="vanilla_attention")## Feed Forwardself.dec = feedforward(self.dec, num_units=[4 * hp.hidden_units, hp.hidden_units])
7、模型输出
decoder的输出会经过一层全联接网络和softmax得到最终的结果,示意图如下:
这样,一个完整的Transformer Architecture我们就介绍完了,对于文中写的不清楚或者不到位的地方,欢迎各位留言指正!
参考文献
1、原文:https://arxiv.org/abs/1706.03762
2、https://mp.weixin.qq.com/s/RLxWevVWHXgX-UcoxDS70w
3、https://github.com/princewen/tensorflow_practice/tree/master/basic/Basic-Transformer-Demo
作者:石晓文的学习日记
链接:https://www.jianshu.com/p/b1030350aadb
来源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。
一步步解析Attention is All You Need相关推荐
- 自然语言处理模型:bert 结构原理解析——attention+transformer(翻译自:Deconstructing BERT)
原文:Deconstructing BERT: Distilling 6 Patterns from 100 Million Parameters 关于transformer 和attention的机 ...
- 【JVM系列】一步步解析java执行内幕
[JVM系列]一步步解析java执行内幕 对于任何一门语言,要想达到精通的水平,研究它的执行原理(或者叫底层机制)不失为一种良好的方式.在本篇文章中,将重点研究java源代码的执行原理,即从程 序员编 ...
- 手机QQ侧滑菜单_从源码上一步步解析效果的实现
本文思想来自洪洋大哥,本来写的原创的,有些朋友看到标题后认为是照搬翔哥的例子,仔细看看,会有不同,不过其中的主要思想还是翔哥的,滑动方面的算法还真是有些区别的,看完了就知道不一样,而且我这人比较啰嗦, ...
- java解析nes_【JVM系列】一步步解析java执行内幕
对于任何一门语言,要想达到精通的水平,研究它的执行原理(或者叫底层机制)不失为一种良好的方式.在本篇文章中,将重点研究java源代码的执行原理,即从程 序员编写JAVA源代码,到最终形成产品,在整个过 ...
- 解析java源代码_一步步解析java执行内幕
对于任何一门语言,要想达到精通的水平,研究它的执行原理(或者叫底层机制)不失为一种良好的方式.在本篇文章中,将重点研究java源代码的执行原理,即从程 序员编写JAVA源代码,到最终形成产品,在整个过 ...
- 【JVM系列】一步步解析java执行内幕,java初级面试笔试题
我总结出了很多互联网公司的面试题及答案,并整理成了文档,以及各种学习的进阶学习资料,免费分享给大家. 扫描二维码或搜索hairyang001加VX好友,拉你进[程序员面试学习交流群]免费领取.也欢迎各 ...
- python 斗地主最优解法_一步步解析Python斗牛游戏的概率
过年回家,都会约上亲朋好友聚聚会,会上经常会打麻将,斗地主,斗牛.在这些游戏中,斗牛是最受欢迎的,因为可以很多人一起玩,而且没有技术含量,都是看运气(专业术语是概率). 斗牛的玩法是: 1.把牌中的J ...
- 一步步解析SVO代码(二)---初始化
SVO系列第二篇,正式开始介绍SVO代码 程序入口 test_pipeline.cpp 主函数 主函数BenchmarkNode的函数. svo::BenchmarkNode benchmark;be ...
- Tensorflow (6) Attention 注意力机制
参考: 细讲 | Attention Is All You Need 关于注意力机制(<Attention is all you need>) 一步步解析Attention is All ...
最新文章
- 2022-2028年中国丝印硅胶行业市场深度分析及投资前景趋势报告
- 深度学习三巨头共同发文,聊聊深度学习的过去、现在与未来
- Discuz! member.php xss bug
- cocoa 坑爹的委托
- 从老赖们“维权”,看拍拍贷的底色
- 使用 C# sdk 连接 高可用的 rabbitmq 镜像集群
- 更改VS的运行主窗体
- button是块级元素吗_前端面试必知必会的十点,你都知道吗?
- js实现表格任意框选_[R] 在表格中插入图形 - formattable + htmlwidgets
- Setup Factory 9 Trial使用
- Java调用Gdal写Esri ShapeFile文件工具类
- pdca管理循环基本主张_“PDCA”循环中的物业质量管理
- 社工必备查询网址汇总
- linux跟单片机的区别,树莓派和单片机的区别
- MOTO me525 DEFY 2.2 刷机全程详细指导
- DuiLib : 做一个没有任务栏图标的Dialog
- 中国行政区划的英文介绍
- python实现求解完美立方等式
- 重庆12岁男孩大毛带着7岁半的弟弟小毛逃学,跑到山里呆了13天
- 【开发心得】java轻量级rpc调用,springBoot集成jsonrpc4j使用
热门文章
- Python爬虫 教程: re正则表达式解析html页面
- Python慢,为啥还有大公司用?
- mysql 修改表id值_修改数据库中表的id
- C语言中函数如何返回结构体?
- 深度学习中不变性是什么?平移不变性Translation Invariance、旋转/视角不变性Ratation/Viewpoint Invariance、尺度不变性Size、Illumination
- 华硕主板X99-E WS/USB 3.1固件更新
- opencv python matplotlib.pyplot.hist() 如何绘制灰度直方图,如何根据灰度直方图确定最优二值化值
- 分布式系统——向zabbix中添加监控项, 以nginx和mysql为例
- Concurrent包下的常用并发类和普通类之间的区别
- 修饰符private和protected详解以及调用Object类Clone方法报错:clone() has protected access in java.lang.Object的原因及解决方案