當前位置：首頁 > 运维知识 > windows >内容正文

windows

【theano-windows】学习笔记十六——深度信念网络DBN

發布時間：2023/12/13 windows 28 豆豆

生活随笔收集整理的這篇文章主要介紹了【theano-windows】学习笔记十六——深度信念网络DBN 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

前言

前面學習了受限玻爾茲曼機(RBM)的理論和搭建方法, 如果稍微了解過的人, 肯定知道利用RBM可以堆疊構成深度信念網絡(deep belief network, DBN)和深度玻爾茲曼機(deep Boltzmann machine), 這里就先學習一下DBN.

國際慣例, 參考博文:

Deep Belief Networks

A fast learning algorithm for deep belief nets

理論

DBN的網絡結構就是簡單地將RBM堆疊起來, 樣子長得就跟全連接一樣.

將第一層作為一個RBM訓練, 輸入是x=h(0), 作為可見層
將第一層得到是輸入表示作為第二層的數據輸入, 有兩種方案, 可以使用P(h(1)=1|h(0))的平均激活, 或者是從P(h(1)|h(0))采樣, 個人覺得前者是針對二值輸入, 后者是真對實值輸入
將第二層作為RBM訓練, 將變換數據(樣本或均值激活)作為訓練樣本
重復第二步和第三步
最后就是微調整個網絡參數,就是傳說中的fine-tuning, 兩種方法, 第一種是使用負對數似然損失的代理方法, 其實論文里面說的就是從上之下的一個算法, 也是Hinton大佬發明的wake-sleep算法, 這個算法經常被用于預訓練AE(詳細請看《視覺機器學習20講》); 另一種方法就是有監督學習算法, 在模型頂上加個分類器作為誤差傳遞的來源.

在教程中, 主要關注監督梯度下降的微調算法, 具體來說就是使用Logistic回歸分類器基于DBN最后一層隱單元的輸出對輸入x分類. 隨后通過負對數似然損失來執行有監督梯度下降, 由于有監督梯度對于權重和隱單元偏置非零(對每層RBM的可見層是零), 這就等價于通過無監督的方式, 為一個深層多層感知器(MLP)進行權重和隱單元偏置的初始化.

為什么這種訓練方法有效？

拿具有兩個隱層(h(1),h(2))的DBN來說, 權重分別為W(1),W(2), Hinton在論文中建立了一個式子logp(x), 如果不懂這個符號的含義, 建議去看看RBM的證明, 戳這里有一個非常非常好的RBM證明文檔, 極為清晰, 極力推薦去看看.

KL(Q(h(1)|x)|p(h(1)|x))=0, 即由模型根據輸入向量得到的特征向量與原始數據本來的真正的特征向量相等, 那么

Q(h(1)|x)=p(h(1)|x), 最終上式結果可以寫成

logp(x)=?∑hQ(h(1)|x)logQ(h(1)|x)+∑hQ(h(1)|x)[logp(h(1))+logp(x|h(1))]
可以發現這個式子與論文的式子完全相同.

正如論文說的, h(0)是第一個隱層的二值向量, p(h(0))是當前模型h(0)的先驗概率, Q(?|x)是基于第一層隱層為條件的任意概率分布, 邊界就是當且僅當Q(?|x)是真實的后驗分布. 當所有的權重被綁定在一起的時候, 將WT1應用到數據向量計算得到基于h(1)的因子分布是真實的后驗分布. 因而在貪婪算法的第二步logp(x)是等于邊界的. 第二步將Q(?|x)和p(x|h(1))固定, 邊界的導數與下式的導數一樣

∑Q(h(1)|x)logp(h(1))
因而最大化高層的比如說權重的邊界實際上等價于最大化數據集的對數概率, 其中

h(1)是由

Q(h(1)|x)產生的. 如果邊界變得更加緊密,

logp(x)有極大可能降低, 即使基于它的較低的邊界增加, 但是

logp(x)不會低于第二步貪婪算法得到的它的值, 因為邊界是很緊密的而且經常處于上升趨勢

代碼實現

可以發現DBN與SdA非常相似, 因為他們都是無監督的層級訓練, 主要區別就是DBN使用層級訓練基礎是RBM, 而SdA使用的層級訓練基礎是dA. 最好復習一下dA的梯度是由什么損失函數得到的, 這樣有助于與RBM做一個區分.

因為采用DBN做無監督訓練, 然后采用MLP微調, 所以直接先建立一個DBN類去作為MLP的層. 因而還是需要用到我們之前的代碼, 包含:

引入各種包
import numpy as np import theano import theano.tensor as T from theano.tensor.shared_randomstreams import RandomStreams import cPickle,gzip from PIL import Image import pylab import os
讀取數據的函數
#定義讀數據的函數,把數據丟入到共享區域def load_data(dataset):data_dir,data_file=os.path.split(dataset)if os.path.isfile(dataset):with gzip.open(dataset,'rb') as f:train_set,valid_set,test_set=cPickle.load(f)#共享數據集def shared_dataset(data_xy,borrow=True):data_x,data_y=data_xyshared_x=theano.shared(np.asarray(data_x,dtype=theano.config.floatX),borrow=borrow)shared_y=theano.shared(np.asarray(data_y,dtype=theano.config.floatX),borrow=borrow)return shared_x,T.cast(shared_y,'int32')#定義三個元組分別存儲訓練集,驗證集,測試集train_set_x,train_set_y=shared_dataset(train_set)valid_set_x,valid_set_y=shared_dataset(valid_set)test_set_x,test_set_y=shared_dataset(test_set)rval=[(train_set_x,train_set_y),(valid_set_x,valid_set_y),(test_set_x,test_set_y)]return rval
定義RBM作為預訓練的基礎, 主要有positive phase、negative phase, 構成Gibbs sampling, 還有能量函數的定義以及使用能量函數做梯度更新的方法
#定義RBMclass RBM(object):def __init__(self,rng=None,trng=None,input=None,n_visible=784,n_hidden=500,W=None,hbias=None,vbias=None):self.n_visible=n_visibleself.n_hidden=n_hiddenif rng is None:rng=np.random.RandomState(1234)if trng is None:trng=RandomStreams(rng.randint(2**30))#初始化權重和偏置 if W is None:initW=np.asarray(rng.uniform(low=-4*np.sqrt(6./(n_hidden+n_visible)),high=4*np.sqrt(6./(n_hidden+n_visible)),size=(n_visible,n_hidden)),dtype=theano.config.floatX)W=theano.shared(value=initW,name='W',borrow=True)if hbias is None:inithbias=np.zeros(n_hidden,dtype=theano.config.floatX)hbias=theano.shared(value=inithbias,name='hbias',borrow=True)if vbias is None:initvbias=np.zeros(n_visible,dtype=theano.config.floatX)vbias=theano.shared(value=initvbias,name='vbias',borrow=True)self.input=inputif not input:self.input=T.matrix('input')self.W=Wself.hbias=hbiasself.vbias=vbiasself.trng=trngself.params=[self.W,self.hbias,self.vbias]##########前向計算,從可見層到隱層#################激活概率def propup(self,vis):pre_sigmoid_activation=T.dot(vis,self.W)+self.hbiasreturn [pre_sigmoid_activation,T.nnet.sigmoid(pre_sigmoid_activation)]#二值激活def sample_h_given_v(self,v0_samples):pre_sigmoid_h1,h1_mean=self.propup(v0_samples)h1_sample=self.trng.binomial(size=h1_mean.shape,n=1,p=h1_mean,dtype=theano.config.floatX)return [pre_sigmoid_h1,h1_mean,h1_sample]##########反向計算,從隱層到可見層#################激活概率def propdown(self,hid):pre_sigmoid_activation=T.dot(hid,self.W.T)+self.vbiasreturn [pre_sigmoid_activation,T.nnet.sigmoid(pre_sigmoid_activation)]#二值激活def sample_v_given_h(self,h0_samples):pre_sigmoid_v1,v1_mean=self.propdown(h0_samples)v1_sample=self.trng.binomial(size=v1_mean.shape,n=1,p=v1_mean,dtype=theano.config.floatX)return [pre_sigmoid_v1,v1_mean,v1_sample]##########吉布斯采樣#################可見層->隱層->可見層def gibbs_vhv(self,v0_samples):pre_sigmoid_h1,h1_mean,h1_sample=self.sample_h_given_v(v0_samples)pre_sigmoid_v1,v1_mean,v1_sample=self.sample_v_given_h(h1_sample)return [pre_sigmoid_v1,v1_mean,v1_sample,pre_sigmoid_h1,h1_mean,h1_sample]############自由能量函數###############def free_energy(self,v_samples):wx_b=T.dot(v_samples,self.W)+self.hbiasvbias_term=T.dot(v_samples,self.vbias)#第一項hidden_term=T.sum(T.log(1+T.exp(wx_b)),axis=1)#第二項return -hidden_term-vbias_term############梯度更新#################def get_cost_updates(self,lr=0.1,k=1):([pre_sigmoid_nvs,nv_means,nv_samples,pre_sigmoid_nhs,nh_means,nh_samples],updates)=\theano.scan(self.gibbs_vhv,outputs_info=[None,None,self.input,None,None,None],n_steps=k,name='gibbs_vhv')chain_end=nv_samples[-1]cost=T.mean(self.free_energy(self.input))-T.mean(self.free_energy(chain_end))gparams=T.grad(cost,self.params,consider_constant=[chain_end])for gparam,param in zip(gparams,self.params):updates[param]=param-gparam*T.cast(lr,dtype=theano.config.floatX)##################期望看到交叉熵損失##############monitor_cost=self.get_reconstruction_cost(pre_sigmoid_nvs[-1])return monitor_cost,updates########非持續性對比散度,重構誤差#########def get_reconstruction_cost(self,pre_sigmoid_nv):cross_entropy=T.mean(T.sum(self.input*T.log(T.nnet.sigmoid(pre_sigmoid_nv))+\(1-self.input)*T.log(1-T.nnet.sigmoid(pre_sigmoid_nv)),axis=1))return cross_entropy
搭建MLP需要的隱層定義
#定義多層感知器的隱層單元相關操作class HiddenLayer(object):def __init__(self,rng,input,n_in,n_out,W=None,b=None,activation=T.tanh):self.input=inputif W is None:W_values=np.asarray(rng.uniform(low=- np.sqrt(6./(n_in+n_out)),high= np.sqrt(6./(n_in+n_out)),size=(n_in,n_out)),dtype=theano.config.floatX)if activation==T.nnet.sigmoid:W_values *= 4W=theano.shared(value=W_values,name='W',borrow=True)if b is None:b_vaules=np.zeros((n_out,),dtype=theano.config.floatX)b=theano.shared(value=b_vaules,name='b',borrow=True)self.W=Wself.b=blin_output=T.dot(input,self.W)+self.b#未被激活的線性操作self.output=(lin_output if activation is None else activation(lin_output))self.params=[self.W,self.b]
最后微調需要softmax
#定義最后一層softmaxclass LogisticRegression(object):def __init__(self,input,n_in,n_out):#共享權重self.W=theano.shared(value=np.zeros((n_in,n_out),dtype=theano.config.floatX),name='W',borrow=True)#共享偏置self.b=theano.shared(value=np.zeros((n_out,),dtype=theano.config.floatX),name='b',borrow=True)#softmax函數self.p_y_given_x=T.nnet.softmax(T.dot(input,self.W)+self.b)#預測值self.y_pred=T.argmax(self.p_y_given_x,axis=1)self.params=[self.W,self.b]#模型參數self.input=input#模型輸入#定義負對數似然def negative_log_likelihood(self,y):return -T.mean(T.log(self.p_y_given_x)[T.arange(y.shape[0]),y])#定義誤差def errors(self, y):# check if y has same dimension of y_predif y.ndim != self.y_pred.ndim:raise TypeError('y should have the same shape as self.y_pred',('y', y.type, 'y_pred', self.y_pred.type))# check if y is of the correct datatypeif y.dtype.startswith('int'):# the T.neq operator returns a vector of 0s and 1s, where 1# represents a mistake in predictionreturn T.mean(T.neq(self.y_pred, y))else:raise NotImplementedError()

準備工作完成以后, 可以進行DBN的定義了, 首先定義結構, 主要包含多個隱層, RBM的逐層訓練, 由于MLP和多個RBM是共享隱單元的, 所以無需重復定義, 但是最后需要使用softmax層作為微調梯度的來源.

class DBN(object):def __init__(self,rng=None,trng=None,n_visible=784,n_hidden=[500,500],n_out=10):self.sigmoid_layers=[]self.rbm_layers=[]self.params=[]self.n_layers=len(n_hidden)assert self.n_layers>0if not trng:trng=RandomStreams(rng.randint(2**30))self.x=T.matrix('x')#輸入self.y=T.ivector('y')#標簽for i in range(self.n_layers):#初始化各隱層if i==0:input_size=n_visibleelse:input_size=n_hidden[i-1]if i==0:layer_input=self.xelse:layer_input=self.sigmoid_layers[-1].output#建立隱層sigmoid_layer=HiddenLayer(rng=rng,input=layer_input,n_in=input_size,n_out=n_hidden[i],activation=T.nnet.sigmoid)self.sigmoid_layers.append(sigmoid_layer)self.params.extend(sigmoid_layer.params)#逐層預訓練rbm_layer=RBM(rng=rng,trng=trng,input=layer_input,n_visible=input_size,n_hidden=n_hidden[i],W=sigmoid_layer.W,hbias=sigmoid_layer.b)self.rbm_layers.append(rbm_layer)#微調分類層self.logLayer=LogisticRegression(input=self.sigmoid_layers[-1].output,n_in=n_hidden[-1],n_out=n_out)self.params.extend(self.logLayer.params)self.finetune_cost=self.logLayer.negative_log_likelihood(self.y)self.errors=self.logLayer.errors(self.y)

這里一定要注意微調分類層不是包含在for循環中的, 雖然大家都知道, 但是寫代碼就是容易發生這個對齊情況, 我當時就寫錯了, 找了半天錯誤, 錯誤提示是

構建DBN 預訓練開始第0層第0次迭代, 損失-98 第1層第0次迭代, 損失-332 第2層第0次迭代, 損失-52 開始微調 --------------------------------------------------------------------------- DisconnectedInputError Traceback (most recent call last) <ipython-input-13-1ad031bf1afb> in <module>() ----> 1 test_DBN()<ipython-input-12-1ea97c3e407d> in test_DBN(pretrain_lr, k, pretrain_epoches, finetune_lr, train_epoch, dataset, batch_size)18 print('第%d層第%d次迭代, 損失%d' %(i,epoch,np.mean(c,dtype='float64')))19 print('開始微調') ---> 20 train_fn,validate_model,test_model=dbn.finetune(datasets=datasets,batch_size=batch_size,learning_rate=finetune_lr)21 patience=4*n_train_batches22 patience_inc=2.0<ipython-input-11-f24396c0dd18> in finetune(self, datasets, batch_size, learning_rate)78 79 index=T.lscalar('index') ---> 80 gparams=T.grad(self.finetune_cost,self.params)81 updates=[]82 for param,gparam in zip(self.params,gparams):C:\ProgramData\Anaconda2\lib\site-packages\theano\gradient.pyc in grad(cost, wrt, consider_constant, disconnected_inputs, add_names, known_grads, return_disconnected, null_gradients)537 if elem not in var_to_app_to_idx and elem is not cost \538 and elem not in grad_dict: --> 539 handle_disconnected(elem)540 grad_dict[elem] = disconnected_type()541 C:\ProgramData\Anaconda2\lib\site-packages\theano\gradient.pyc in handle_disconnected(var)524 elif disconnected_inputs == 'raise':525 message = utils.get_variable_trace_string(var) --> 526 raise DisconnectedInputError(message)527 else:528 raise ValueError("Invalid value for keyword "DisconnectedInputError: Backtrace when that variable is created:File "C:\ProgramData\Anaconda2\lib\site-packages\ipykernel\zmqshell.py", line 533, in run_cellreturn super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)File "C:\ProgramData\Anaconda2\lib\site-packages\IPython\core\interactiveshell.py", line 2718, in run_cellinteractivity=interactivity, compiler=compiler, result=result)File "C:\ProgramData\Anaconda2\lib\site-packages\IPython\core\interactiveshell.py", line 2828, in run_ast_nodesif self.run_code(code, result):File "C:\ProgramData\Anaconda2\lib\site-packages\IPython\core\interactiveshell.py", line 2882, in run_codeexec(code_obj, self.user_global_ns, self.user_ns)File "<ipython-input-13-1ad031bf1afb>", line 1, in <module>test_DBN()File "<ipython-input-12-1ea97c3e407d>", line 10, in test_DBNdbn=DBN(rng=rng,trng=RandomStreams(rng.randint(2**30)),n_visible=28*28,n_hidden=[1000, 500, 400],n_out=10)File "<ipython-input-11-f24396c0dd18>", line 49, in __init__n_out=n_out)File "<ipython-input-5-22c6bb9a49a7>", line 7, in __init__borrow=True)

然后就可以定義預訓練過程了,逐層更新, 依舊是使用for循環

def pretrain(self,train_set,batch_size,k):index=T.lscalar('index')learning_rate=T.scalar('lr')batch_begin=index*batch_sizebatch_end=batch_begin+batch_sizepretrain_fns=[]for rbm in self.rbm_layers:cost,updates=rbm.get_cost_updates(learning_rate,k=k)fn=theano.function(inputs=[index,theano.In(learning_rate,value=0.1)],outputs=cost,updates=updates,givens={self.x:train_set[batch_begin:batch_end]})pretrain_fns.append(fn)return pretrain_fns

微調階段與MLP的構建一樣, 利用訓練集更新參數, 利用驗證集和測試集查看模型效果

def finetune(self,datasets,batch_size,learning_rate):(train_set_x,train_set_y)=datasets[0](valid_set_x,valid_set_y)=datasets[1](test_set_x,test_set_y)=datasets[2]n_valid_batches=valid_set_x.get_value(borrow=True).shape[0]n_valid_batches//=batch_sizen_test_batches=test_set_x.get_value(borrow=True).shape[0]n_test_batches//=batch_sizeindex=T.lscalar('index')gparams=T.grad(self.finetune_cost,self.params)updates=[]for param,gparam in zip(self.params,gparams):updates.append((param,param-gparam*learning_rate))train_fn=theano.function(inputs=[index],outputs=self.finetune_cost,updates=updates,givens={self.x:train_set_x[index*batch_size:(index+1)*batch_size],self.y:train_set_y[index*batch_size:(index+1)*batch_size]})valid_score=theano.function(inputs=[index],outputs=self.errors,givens={self.x:valid_set_x[index*batch_size:(index+1)*batch_size],self.y:valid_set_y[index*batch_size:(index+1)*batch_size]})test_score=theano.function(inputs=[index],outputs=self.errors,givens={self.x:test_set_x[index*batch_size:(index+1)*batch_size],self.y:test_set_y[index*batch_size:(index+1)*batch_size]})

對于驗證集和測試集, 我們希望得到準確率信息

def valid():return [valid_score(i) for i in range(n_valid_batches)]def test():return [test_score(i) for i in range(n_test_batches)]return train_fn,valid,test

最終運行階段, 首先初始化一個DBN網絡

datasets=load_data(dataset)train_set_x,train_set_y=datasets[0]n_train_batches=train_set_x.get_value(borrow=True).shape[0]//batch_sizeprint('構建DBN')rng=np.random.RandomState(123)trng=RandomStreams(rng.randint(2**30))dbn=DBN(rng=rng,trng=RandomStreams(rng.randint(2**30)),n_visible=28*28,n_hidden=[500, 200, 100],n_out=10)

然后正式逐層RBM預訓練

print('預訓練開始')pretrain_fns=dbn.pretrain(train_set=train_set_x,batch_size=batch_size,k=k)for i in range(dbn.n_layers):for epoch in range(pretrain_epoches):c=[]for batch_index in range(n_train_batches):c.append(pretrain_fns[i](index=batch_index,lr=pretrain_lr))print('第%d層第%d次迭代, 損失%d' %(i,epoch,np.mean(c,dtype='float64')))

提前終止算法微調

print('開始微調')train_fn,validate_model,test_model=dbn.finetune(datasets=datasets,batch_size=batch_size,learning_rate=finetune_lr)patience=4*n_train_batchespatience_inc=2.0imp_threshold=0.995valid_frequence=min(n_train_batches,patience/2)best_loss=np.inftest_socre=0.0done_loop=Falseepoch=0while(epoch<train_epoch) and (not done_loop):epoch=epoch+1for minibatch_index in range(n_train_batches):train_fn(minibatch_index)iter=(epoch-1)*n_train_batches+minibatch_indexif (iter+1)%valid_frequence==0:valid_loss=validate_model()this_valid_loss=np.mean(valid_loss,dtype='float64')print('第%d次迭代, 第%d個批次,驗證誤差為%f %%' %(epoch,minibatch_index+1,this_valid_loss*100))if this_valid_loss<best_loss:if this_valid_loss<best_loss*imp_threshold:patience=max(patience,iter*patience_inc)best_loss=this_valid_lossbest_iter=itertest_loss=test_model()test_score=np.mean(test_loss,dtype='float64')print('第%d次訓練, 第%d批數據,測試誤差為%f %%' %(epoch,minibatch_index+1,test_score*100.0))if patience<=iter:done_loop=Truebreak

模型的保存方法就不寫了, 和MLP的差不多, 主要還是因為我python不是特別好, 搞不好又出一堆錯誤, 訓練結果如下:

構建DBN 預訓練開始第0層第0次迭代, 損失-106 第1層第0次迭代, 損失-180 第2層第0次迭代, 損失-38 開始微調第1次迭代, 第5000個批次,驗證誤差為5.360000 % 第1次訓練, 第5000批數據,測試誤差為6.100000 % 第2次迭代, 第5000個批次,驗證誤差為4.100000 % 第2次訓練, 第5000批數據,測試誤差為4.510000 % 第3次迭代, 第5000個批次,驗證誤差為3.490000 % 第3次訓練, 第5000批數據,測試誤差為4.030000 % 第4次迭代, 第5000個批次,驗證誤差為3.250000 % 第4次訓練, 第5000批數據,測試誤差為3.560000 % 第5次迭代, 第5000個批次,驗證誤差為3.020000 % 第5次訓練, 第5000批數據,測試誤差為3.320000 % 第6次迭代, 第5000個批次,驗證誤差為2.830000 % 第6次訓練, 第5000批數據,測試誤差為3.220000 % 第7次迭代, 第5000個批次,驗證誤差為2.790000 % 第7次訓練, 第5000批數據,測試誤差為2.990000 % 第8次迭代, 第5000個批次,驗證誤差為2.650000 % 第8次訓練, 第5000批數據,測試誤差為2.800000 % 第9次迭代, 第5000個批次,驗證誤差為2.600000 % 第9次訓練, 第5000批數據,測試誤差為2.690000 % 第10次迭代, 第5000個批次,驗證誤差為2.620000 % 第11次迭代, 第5000個批次,驗證誤差為2.570000 % 第11次訓練, 第5000批數據,測試誤差為2.580000 % 第12次迭代, 第5000個批次,驗證誤差為2.480000 % 第12次訓練, 第5000批數據,測試誤差為2.580000 % 第13次迭代, 第5000個批次,驗證誤差為2.460000 % 第13次訓練, 第5000批數據,測試誤差為2.590000 % 第14次迭代, 第5000個批次,驗證誤差為2.440000 % 第14次訓練, 第5000批數據,測試誤差為2.520000 % 第15次迭代, 第5000個批次,驗證誤差為2.370000 % 第15次訓練, 第5000批數據,測試誤差為2.500000 % 第16次迭代, 第5000個批次,驗證誤差為2.320000 % 第16次訓練, 第5000批數據,測試誤差為2.460000 % 第17次迭代, 第5000個批次,驗證誤差為2.310000 % 第17次訓練, 第5000批數據,測試誤差為2.510000 % 第18次迭代, 第5000個批次,驗證誤差為2.310000 % 第19次迭代, 第5000個批次,驗證誤差為2.260000 % 第19次訓練, 第5000批數據,測試誤差為2.430000 % 第20次迭代, 第5000個批次,驗證誤差為2.230000 % 第20次訓練, 第5000批數據,測試誤差為2.360000 %

后記

自己寫代碼的時候主要就是剛才提到的那個對齊錯誤, 導致整個程序的錯誤日志有點看不懂, 大概意思就是梯度更新的位置出現了問題, 但是導致梯度出問題的原因可能有很多, 當代碼量較大的時候就不太好查找了, 所以大家寫代碼一定要仔細仔細仔細.

博文代碼:鏈接: https://pan.baidu.com/s/1gfaTR6z 密碼: fhe2

總結

以上是生活随笔為你收集整理的【theano-windows】学习笔记十六——深度信念网络DBN的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：平安银行信用卡激活有效期是多久？这几种方
下一篇：信用卡还款了多久可以刷出来？还款了怎么还