batches是什么意思,batches的意思翻译、用法、同义词、例(Mamba的架构及实现)

大家好，感谢邀请，今天来为大家分享一下batches是什么意思,batches的意思翻译、用法、同义词、例的问题，以及和Mamba的架构及实现的一些困惑，大家要是还不太明白的话，也没有关系，因为接下来将为大家分享，希望可以帮助到大家，解决大家的问题，下面就开始吧！

来源：算法进阶

本文约5500字，建议阅读11分钟

本文详细研究这篇论文《Mamba:具有选择性状态空间的线性时间序列建模》。

Mamba一经出现就在人工智能界掀起波澜，被吹捧为Transformer的竞争对手。到底是什么让Mamba在拥挤的序列建模中脱颖而出?今天我们来详细研究这篇论文《Mamba:具有选择性状态空间的线性时间序列建模》

在介绍之前先简要回顾一下现有的模型

Transformer:以其注意力机制而闻名，其中序列的任何部分都可以动态地与任何其他部分相互作用，特别是具有因果注意力机制的Transformer，擅长处理序列中的单个元素。但是它们带来了显著的计算和内存成本，与序列长度的平方(L2)成比例。

循环神经网络(rnn):rnn只考虑当前输入和最后一个隐藏状态，按顺序更新隐藏状态。这种方法允许它们潜在地处理无限序列长度和恒定的内存需求。但是rnn的简单性是一个缺点，限制了它们记住长期依赖关系的能力。此外，rnn中的时间反向传播(BPTT)是内存密集型的，并且可能遭受梯度消失或爆炸的影响，尽管有LSTM等创新部分解决了这个问题。

StateSpaceModels(S4):这些模型已经显示出很好的特性。它们提供了一种平衡，比rnn更有效地捕获远程依赖关系，同时比transformer更高效地使用内存。

接下来Manba登场！

选择性状态空间:Mamba建立在状态空间模型的概念之上，但它引入了一个新的变化。它利用选择性状态空间，支持跨长序列更高效和有效地捕获相关信息。

线性时间复杂度:与Transformer不同，Mamba在序列长度方面以线性时间运行。这个属性使得它特别适合涉及非常长的序列的任务，而传统模型在这方面会遇到困难。

Mamba以其选择性状态空间的概念引入了传统状态空间模型的一个有趣的改进。这种方法稍微放松了标准状态空间模型的严格状态转换，使其更具适应性和灵活性（有点类似于lstm）。并且Mamba保留了状态空间模型的高效计算特性，使其能够在一次扫描中执行整个序列的前向传递——这一特性更让人想起Transformer。

在训练期间，Mamba的行为类似于Transformer，同时处理整个序列。而lstm必须一步一步地计算前向传递，即使所有输入都是已知的。在推理中，Mamba的行为更符合传统的循环模型，提供有效的序列处理。

先验状态空间模型(ssm)的一个关键限制是其刚性的、输入不变的结构。这些模型为整个序列使用一组固定参数(我们称它们为a和B)。这种结构甚至比lstm等模型更具限制性，在lstm中，信号的转换可能依赖于先前的隐藏状态和输入。

Mamba则是一种范式转换，即如何计算向下一个隐藏状态的过渡？在Mamba的体系结构中，转换依赖于当前输入，这种方法在传统ssm的固定计算和循环神经网络的输入依赖动态性之间取得了平衡。

固定主干:从一个隐藏状态到下一个隐藏状态的转换仍然是一个固定的计算(由a矩阵定义)，允许跨序列的预计算。

输入相关转换:输入影响下一个隐藏状态(由B矩阵定义)的方式取决于当前输入，而不是之前的隐藏状态。与传统ssm相比，这种输入依赖性提供了更大的灵活性。

为了满足这种方法的计算需求，Mamba使用了一种硬件感知算法。该算法使用扫描操作而不是卷积来循环执行计算，这样在gpu上是非常高效的。尽管输入依赖转换带来了算法复杂性，但这种效率对于保持高性能至关重要。

Mamba和选择性状态空间模型不是同义词。Mamba是一个使用选择性状态空间概念的实现。这种区别是至关重要的，因为它突出了Mamba的独特贡献:在保持计算效率的同时，使ssm框架更加灵活和相应输入。

gpu包含两种主要类型的内存:HBM(HighBandwidthmemory)和SRAM(StaticRandom-Accessmemory)。HBM虽然带宽很高，但与更快但更小的SRAM相比，它的访问时间相对较慢。Mamba则使用SRAM在矩阵乘法期间进行快速访问，这是其计算的关键。

计算中的主要瓶颈通常不是计算本身，而是数据在内存类型之间的移动。Mamba通过显著减少传输大量数据的需求来解决这个问题。它通过直接在SRAM中执行算法的关键部分(如离散化和递归计算)来实现，从而减少延迟。

还引入了一个融合选择扫描层，使其内存需求与使用flashattention的优化Transformer实现相当。这一层对于保持效率至关重要，尤其是在处理模型中依赖于输入的元素时。

Mamba代表了序列建模的重大进步，特别是在其高效使用GPU内存和计算策略方面。它具有高效率处理长序列的能力，使其成为各种应用的有前途的模型，我们下面来使用Pytorch来对其进复现。

importtorch\nimporttorch.nnasnn\nimporttorch.optimasoptim\nfromtorch.utils.dataimportDataLoader,Dataset\nfromtorch.nnimportfunctionalasF\nfromeinopsimportrearrange\nfromtqdmimporttqdm\n\n\nimportmath\nimportos\nimporturllib.request\nfromzipfileimportZipFile\n\n\nfromtransformersimportAutoTokenizer\n\n\ntorch.autograd.set_detect_anomaly(True)

设置标志和超参数

#Configurationflagsandhyperparameters\nUSE_MAMBA=1\nDIFFERENT_H_STATES_RECURRENT_UPDATE_MECHANISM=0\n\n\ndevice=torch.device('cuda'iftorch.cuda.is_available()else'cpu')

定义超参数和初始化

d_model=8\nstate_size=128#Examplestatesize\nseq_len=100#Examplesequencelength\nbatch_size=256#Examplebatchsize\nlast_batch_size=81#onlyfortheverylastbatchofthedataset\ncurrent_batch_size=batch_size\ndifferent_batch_size=False\nh_new=None\ntemp_buffer=None

这里的超参数，如模型维度(d_model)、状态大小、序列长度和批大小。

S6模块是Mamba架构中的一个复杂组件，负责通过一系列线性变换和离散化过程处理输入序列。它在捕获序列的时间动态方面起着关键作用，这是序列建模任务(如语言建模)的一个关键方面。这里包括张量运算和自定义离散化方法来处理序列数据的复杂需求。

classS6(nn.Module):\ndef__init__(self,seq_len,d_model,state_size,device):\nsuper(S6,self).__init__()\n\n\nself.fc1=nn.Linear(d_model,d_model,device=device)\nself.fc2=nn.Linear(d_model,state_size,device=device)\nself.fc3=nn.Linear(d_model,state_size,device=device)\n\n\nself.seq_len=seq_len\nself.d_model=d_model\nself.state_size=state_size\n\n\n\n\nself.A=nn.Parameter(F.normalize(torch.ones(d_model,state_size,device=device),p=2,dim=-1))\nnn.init.xavier_uniform_(self.A)\n\n\nself.B=torch.zeros(batch_size,self.seq_len,self.state_size,device=device)\nself.C=torch.zeros(batch_size,self.seq_len,self.state_size,device=device)\n\n\nself.delta=torch.zeros(batch_size,self.seq_len,self.d_model,device=device)\nself.dA=torch.zeros(batch_size,self.seq_len,self.d_model,self.state_size,device=device)\nself.dB=torch.zeros(batch_size,self.seq_len,self.d_model,self.state_size,device=device)\n\n\n#h[batch_size,seq_len,d_model,state_size]\nself.h=torch.zeros(batch_size,self.seq_len,self.d_model,self.state_size,device=device)\nself.y=torch.zeros(batch_size,self.seq_len,self.d_model,device=device)\n\n\n\n\ndefdiscretization(self):\n\n\nself.dB=torch.einsum("bld,bln->bldn",self.delta,self.B)\n\n\nself.dA=torch.exp(torch.einsum("bld,dn->bldn",self.delta,self.A))\n\n\n\n\nreturnself.dA,self.dB\n\n\ndefforward(self,x):\n#Algorithm2MAMBApaper\nself.B=self.fc2(x)\nself.C=self.fc3(x)\nself.delta=F.softplus(self.fc1(x))\n\n\nself.discretization()\n\n\nifDIFFERENT_H_STATES_RECURRENT_UPDATE_MECHANISM:\n\n\nglobalcurrent_batch_size\ncurrent_batch_size=x.shape[0]\n\n\nifself.h.shape[0]!=current_batch_size:\ndifferent_batch_size=True\n\n\nh_new=torch.einsum('bldn,bldn->bldn',self.dA,self.h[:current_batch_size,...])+rearrange(x,"bld->bld1")*self.dB\n\n\nelse:\ndifferent_batch_size=False\nh_new=torch.einsum('bldn,bldn->bldn',self.dA,self.h)+rearrange(x,"bld->bld1")*self.dB\n\n\n#y[batch_size,seq_len,d_model]\nself.y=torch.einsum('bln,bldn->bld',self.C,h_new)\n\n\nglobaltemp_buffer\ntemp_buffer=h_new.detach().clone()ifnotself.h.requires_gradelseh_new.clone()\n\n\nreturnself.y\n\n\nelse:\n#h[batch_size,seq_len,d_model,state_size]\nh=torch.zeros(x.size(0),self.seq_len,self.d_model,self.state_size,device=x.device)\ny=torch.zeros_like(x)\n\n\nh=torch.einsum('bldn,bldn->bldn',self.dA,h)+rearrange(x,"bld->bld1")*self.dB\n\n\n#y[batch_size,seq_len,d_model]\ny=torch.einsum('bln,bldn->bld',self.C,h)\n\n\nreturny

这个S6的模块，可以处理离散化过程和正向传播。

MambaBlock类是一个定制的神经网络模块，被设计为Mamba模型的关键构建块。它封装了几个层和操作来处理输入数据。

包括线性投影、卷积、激活函数、自定义S6模块和残差连接。该块是Mamba模型的基本组件，负责通过一系列转换处理输入序列，以捕获数据中的相关模式和特征。这些不同层和操作的组合允许MambaBlock有效地处理复杂的序列建模任务。MambaBlock是Mamba核心功能。

classMambaBlock(nn.Module):\ndef__init__(self,seq_len,d_model,state_size,device):\nsuper(MambaBlock,self).__init__()\n\n\nself.inp_proj=nn.Linear(d_model,2*d_model,device=device)\nself.out_proj=nn.Linear(2*d_model,d_model,device=device)\n\n\n#Forresidualskipconnection\nself.D=nn.Linear(d_model,2*d_model,device=device)\n\n\n#Set_no_weight_decayattributeonbias\nself.out_proj.bias._no_weight_decay=True\n\n\n#Initializebiastoasmallconstantvalue\nnn.init.constant_(self.out_proj.bias,1.0)\n\n\nself.S6=S6(seq_len,2*d_model,state_size,device)\n\n\n#Add1Dconvolutionwithkernelsize3\nself.conv=nn.Conv1d(seq_len,seq_len,kernel_size=3,padding=1,device=device)\n\n\n#Addlinearlayerforconvoutput\nself.conv_linear=nn.Linear(2*d_model,2*d_model,device=device)\n\n\n#rmsnorm\nself.norm=RMSNorm(d_model,device=device)\n\n\ndefforward(self,x):\n"""\nx_proj.shape=torch.Size([batch_size,seq_len,2*d_model])\nx_conv.shape=torch.Size([batch_size,seq_len,2*d_model])\nx_conv_act.shape=torch.Size([batch_size,seq_len,2*d_model])\n"""\n#RefertoFigure3intheMAMBApaper\n\n\nx=self.norm(x)\n\n\nx_proj=self.inp_proj(x)\n\n\n#Add1Dconvolutionwithkernelsize3\nx_conv=self.conv(x_proj)\n\n\nx_conv_act=F.silu(x_conv)\n\n\n#Addlinearlayerforconvoutput\nx_conv_out=self.conv_linear(x_conv_act)\n\n\nx_ssm=self.S6(x_conv_out)\nx_act=F.silu(x_ssm)#Swishactivationcanbeimplementedasx*sigmoid(x)\n\n\n#residualskipconnectionwithnonlinearityintroducedbymultiplication\nx_residual=F.silu(self.D(x))\n\n\nx_combined=x_act*x_residual\n\n\nx_out=self.out_proj(x_combined)\n\n\nreturnx_out

Mamba模型

包括一系列MambaBlock模块。每个块都顺序处理输入数据，一个块的输出作为下一个块的输入。这种顺序处理允许模型捕获输入数据中的复杂模式和关系，使其对涉及顺序建模的任务有效。多个块的堆叠是深度学习架构中的常见设计，因为它使模型能够学习数据的分层表示。

classMamba(nn.Module):\ndef__init__(self,seq_len,d_model,state_size,device):\nsuper(Mamba,self).__init__()\nself.mamba_block1=MambaBlock(seq_len,d_model,state_size,device)\nself.mamba_block2=MambaBlock(seq_len,d_model,state_size,device)\nself.mamba_block3=MambaBlock(seq_len,d_model,state_size,device)\n\n\ndefforward(self,x):\nx=self.mamba_block1(x)\nx=self.mamba_block2(x)\nx=self.mamba_block3(x)\nreturnx

RMSNorm是一个自定义规范化层，这一层用于规范神经网络的激活，这可以帮助稳定和加快训练。

classRMSNorm(nn.Module):\ndef__init__(self,\nd_model:int,\neps:float=1e-5,\ndevice:str='cuda'):\nsuper().__init__()\nself.eps=eps\nself.weight=nn.Parameter(torch.ones(d_model,device=device))\n\n\n\n\ndefforward(self,x):\noutput=x*torch.rsqrt(x.pow(2).mean(-1,keepdim=True)+self.eps)*self.weight\n\n\nreturnoutput

这一层的用法：

x=torch.rand(batch_size,seq_len,d_model,device=device)\n#CreatetheMambamodel\nmamba=Mamba(seq_len,d_model,state_size,device)\n\n\n#rmsnorm\nnorm=RMSNorm(d_model)\nx=norm(x)\n\n\n#Forwardpass\ntest_output=mamba(x)\nprint(f"test_output.shape={test_output.shape}")#Shouldbe[batch_size,seq_len,d_model]

上面就是模型的全部基本代码，下面就可以进行数据准备和训练

classEnwiki8Dataset(Dataset):\ndef__init__(self,data):\nself.data=data\n\n\ndef__len__(self):\nreturnlen(self.data['input_ids'])\n\n\ndef__getitem__(self,idx):\nitem={key:val[idx].clone().detach()forkey,valinself.data.items()}\nreturnitem

pad_sequences_3d用于将一批序列填充到统一的长度，确保批中的每个序列具有相同数量的元素(或时间步长)。这在许多机器学习任务中尤其重要，因为输入数据必须具有一致的形状。

#Defineafunctionforpadding\ndefpad_sequences_3d(sequences,max_len=None,pad_value=0):\n#Assumingsequencesisatensorofshape(batch_size,seq_len,feature_size)\nbatch_size,seq_len,feature_size=sequences.shape\n\n\nifmax_lenisNone:\nmax_len=seq_len+1\n\n\n\n\n#Initializepadded_sequenceswiththepad_value\npadded_sequences=torch.full((batch_size,max_len,feature_size),fill_value=pad_value,dtype=sequences.dtype,device=sequences.device)\n#Padeachsequencetothemax_len\npadded_sequences[:,:seq_len,:]=sequences\n\n\nreturnpadded_sequences

训练过程：

deftrain(model,tokenizer,data_loader,optimizer,criterion,device,max_grad_norm=1.0,DEBUGGING_IS_ON=False):\nmodel.train()\ntotal_loss=0\nforbatchindata_loader:\noptimizer.zero_grad()\n\n\ninput_data=batch['input_ids'].clone().to(device)\nattention_mask=batch['attention_mask'].clone().to(device)\n\n\ntarget=input_data[:,1:]\ninput_data=input_data[:,:-1]\n\n\n#Padallthesequencesinthebatch:\ninput_data=pad_sequences_3d(input_data,pad_value=tokenizer.pad_token_id)\ntarget=pad_sequences_3d(target,max_len=input_data.size(1),pad_value=tokenizer.pad_token_id)\n\n\nifUSE_MAMBA:\noutput=model(input_data)\nloss=criterion(output,target)\n\n\nloss.backward(retain_graph=True)\n\n\nforname,paraminmodel.named_parameters():\nif'out_proj.bias'notinname:\n#clipweightsbutnotbiasforout_proj\ntorch.nn.utils.clip_grad_norm_(param,max_norm=max_grad_norm)\n\n\nifDEBUGGING_IS_ON:\nforname,parameterinmodel.named_parameters():\nifparameter.gradisnotNone:\nprint(f"{name}gradient:{parameter.grad.data.norm(2)}")\nelse:\nprint(f"{name}hasnogradient")\n\n\nifUSE_MAMBAandDIFFERENT_H_STATES_RECURRENT_UPDATE_MECHANISM:\nmodel.S6.h[:current_batch_size,...].copy_(temp_buffer)\n\n\noptimizer.step()\n\n\ntotal_loss+=loss.item()\nreturntotal_loss/len(data_loader)

评估函数：

defevaluate(model,data_loader,criterion,device):\nmodel.eval()\ntotal_loss=0\nwithtorch.no_grad():\nforbatchindata_loader:\ninput_data=batch['input_ids'].clone().detach().to(device)\nattention_mask=batch['attention_mask'].clone().detach().to(device)\n\n\ntarget=input_data[:,1:]\ninput_data=input_data[:,:-1]\n\n\n#Padallthesequencesinthebatch:\ninput_data=pad_sequences_3d(input_data,pad_value=tokenizer.pad_token_id)\ntarget=pad_sequences_3d(target,max_len=input_data.size(1),pad_value=tokenizer.pad_token_id)\n\n\nifUSE_MAMBA:\noutput=model(input_data)\nloss=criterion(output,target)\ntotal_loss+=loss.item()\nreturntotal_loss/len(data_loader)

最后，calculate_perplexity用于评估语言模型(如Mamba)的性能。

defcalculate_perplexity(loss):\nreturnmath.exp(loss)

load_enwiki8_dataset函数用于下载和提取enwiki8数据集，该数据集通常用于对语言模型进行基准测试。

defload_enwiki8_dataset():\nprint(f"Downloadandextractenwiki8data")\nurl="http://mattmahoney.net/dc/enwik8.zip"\nurllib.request.urlretrieve(url,"enwik8.zip")\n\n\nwithZipFile("enwik8.zip")asf:\ndata=f.read("enwik8").decode("utf-8")\n\n\nreturndata

encode_dataset函数设计用于标记和编码数据集，为神经网络模型(如Mamba)处理数据集做准备。

#Tokenizeandencodethedataset\ndefencode_dataset(tokenizer,text_data):\ndefbatch_encode(tokenizer,text_data,batch_size=1000):\n#Tokenizeinbatches\nbatched_input_ids=[]\nforiinrange(0,len(text_data),batch_size):\nbatch=text_data[i:i+batch_size]\ninputs=tokenizer(batch,add_special_tokens=True,truncation=True,\npadding='max_length',max_length=seq_len,\nreturn_tensors='pt')\nbatched_input_ids.append(inputs['input_ids'])\nreturntorch.cat(batched_input_ids)\n\n\n#Assumingenwiki8_dataisalistofsentences\ninput_ids=batch_encode(tokenizer,enwiki8_data)\n\n\n#vocab_sizeisthenumberofuniquetokensinthetokenizer'svocabulary\nglobalvocab_size\nvocab_size=len(tokenizer.vocab)#Notethatforsometokenizers,wemightaccessthevocabdirectly\nprint(f"vocab_size={vocab_size}")\n\n\n#Createanembeddinglayer\n#embedding_dimisthesizeoftheembeddingvectors(MAMBAmodel'sD)\nembedding_layer=nn.Embedding(num_embeddings=vocab_size,embedding_dim=d_model)\n\n\n#Pass`input_ids`throughtheembeddinglayer\n#Thiswillchange`input_ids`fromshape[B,L]to[B,L,D]\ndefbatch_embedding_calls(input_ids,embedding_layer,batch_size=256):\n#Checkifinput_idsisalreadyatensor,ifnotconvertit\nifnotisinstance(input_ids,torch.Tensor):\ninput_ids=torch.tensor(input_ids,dtype=torch.long)\n\n\n#Calculatethenumberofbatchesneeded\nnum_batches=math.ceil(input_ids.size(0)/batch_size)\n\n\n#Listtoholdtheoutputembeddings\noutput_embeddings=[]\n\n\n#Processeachbatch\nforiinrange(num_batches):\n#Calculatestartandendindicesforthecurrentbatch\nstart_idx=i*batch_size\nend_idx=start_idx+batch_size\n\n\n#Getthebatch\ninput_id_batch=input_ids[start_idx:end_idx]\n\n\n#Calltheembeddinglayer\nwithtorch.no_grad():#Noneedgradientsforthisoperation\nbatch_embeddings=embedding_layer(input_id_batch)\n\n\n#Appendtheresulttothelist\noutput_embeddings.append(batch_embeddings)\n\n\n#Concatenatetheembeddingsfromeachbatchintoasingletensor\nall_embeddings=torch.cat(output_embeddings,dim=0)\n\n\nreturnall_embeddings\n\n\n#`input_ids`isalistortensoroftheinputIDsand`embedding_layer`ismodel'sembeddinglayer\nifUSE_MAMBA:\n#Set`batch_size`toavaluethatworksformemoryconstraints\nencoded_inputs=batch_embedding_calls(input_ids,embedding_layer,batch_size=1).float()\n\n\nattention_mask=(input_ids!=tokenizer.pad_token_id).type(input_ids.dtype)\n\n\nreturnencoded_inputs,attention_mask

下面就可以进行训练了

#Loadapretrainedtokenizer\ntokenizer=AutoTokenizer.from_pretrained('bert-base-uncased')\n\n\n#Assumingencoded_inputsisapreprocessedtensorofshape[num_samples,seq_len,d_model]\nencoded_inputs_file='encoded_inputs_mamba.pt'\n\n\n\n\nifos.path.exists(encoded_inputs_file):\nprint("Loadingpre-tokenizeddata...")\nencoded_inputs=torch.load(encoded_inputs_file)\nelse:\nprint("Tokenizingrawdata...")\nenwiki8_data=load_enwiki8_dataset()\nencoded_inputs,attention_mask=encode_dataset(tokenizer,enwiki8_data)\ntorch.save(encoded_inputs,encoded_inputs_file)\nprint(f"finishedtokenizingdata")\n\n\n\n\n#Combineintoasingledictionary\ndata={\n'input_ids':encoded_inputs,\n'attention_mask':attention_mask\n}\n\n\n#Splitthedataintotrainandvalidationsets\ntotal_size=len(data['input_ids'])\ntrain_size=int(total_size*0.8)\n\n\ntrain_data={key:val[:train_size]forkey,valindata.items()}\nval_data={key:val[train_size:]forkey,valindata.items()}\n\n\ntrain_dataset=Enwiki8Dataset(train_data)\nval_dataset=Enwiki8Dataset(val_data)\n\n\n\n\ntrain_loader=DataLoader(train_dataset,batch_size=batch_size,shuffle=True)\nval_loader=DataLoader(val_dataset,batch_size=batch_size,shuffle=False)\n\n\n\n\n#Initializethemodel\n\n\nmodel=Mamba(seq_len,d_model,state_size,device).to(device)\n\n\n#Definethelossfunctionandoptimizer\ncriterion=nn.CrossEntropyLoss()\noptimizer=optim.AdamW(model.parameters(),lr=5e-6)\n\n\n#Trainingloop\nnum_epochs=25#Numberofepochstotrainfor\n\n\nforepochintqdm(range(num_epochs)):#loopoverthedatasetmultipletimes\ntrain_loss=train(model,tokenizer,train_loader,optimizer,criterion,device,max_grad_norm=10.0,DEBUGGING_IS_ON=False)\nval_loss=evaluate(model,val_loader,criterion,device)\nval_perplexity=calculate_perplexity(val_loss)\nprint(f'Epoch:{epoch+1},TrainingLoss:{train_loss:.4f},ValidationLoss:{val_loss:.4f},ValidationPerplexity:{val_perplexity:.4f}')

以上就是训练的完整代码。

我们介绍了Mamba的概念和架构，并且从头开始构建Mamba复现，这样可以将理论转化为实践。通过这种动手的方法，可以看到Mamba序列建模方法和效率。如果你想直接使用，可以看论文提供的代码。

https://arxiv.org/abs/2312.00752

https://github.com/state-spaces/mamba

关于batches是什么意思,batches的意思翻译、用法、同义词、例到此分享完毕，希望能帮助到您。