深度学习：长短期记忆网络（LSTM）：LSTM网络的优化技巧

深度学习：长短期记忆网络（LSTM）：LSTM网络的优化技巧1深度学习：长短期记忆网络（LSTM）基础1.1LSTM单元结构详解LSTM,或长短期记忆网络,是一种特殊的循环神经网络（RNN）架构，设计用于解决长期依赖问题。其核心是LSTM单元，每个单元包含三个主要的门控机制：输入门、遗忘门和输出门，以及一个记忆单元（cellstate）。1.1.1输入门（InputGate）输入门决定哪些信息将被存储到记忆单元中。它由一个sigmoid层和一个tanh层组成。sigmoid层输出一个0到1之间的值，表示每个组件被更新的程度；tanh层产生一个候选记忆值，然后与sigmoid层的输出相乘，决定实际更新到记忆单元中的信息。#PyTorch实现LSTM输入门

importtorch

importtorch.nnasnn

classInputGate(nn.Module):

def__init__(self,input_size,hidden_size):

super(InputGate,self).__init__()

self.Wi=nn.Linear(input_size+hidden_size,hidden_size)

self.Ui=nn.Linear(hidden_size,hidden_size)

self.Wc=nn.Linear(input_size+hidden_size,hidden_size)

defforward(self,x,h_prev,c_prev):

#输入门的sigmoid层

i_t=torch.sigmoid(self.Wi(torch.cat([x,h_prev],dim=1))+self.Ui(h_prev))

#候选记忆值的tanh层

c_tilde=torch.tanh(self.Wc(torch.cat([x,h_prev],dim=1)))

#更新记忆单元

c_next=torch.mul(i_t,c_tilde)+torch.mul(c_prev,1-i_t)

returnc_next1.1.2遗忘门（ForgetGate）遗忘门决定哪些信息将从记忆单元中被丢弃。它同样由一个sigmoid层组成，输出值决定每个记忆单元组件被遗忘的程度。#PyTorch实现LSTM遗忘门

classForgetGate(nn.Module):

def__init__(self,input_size,hidden_size):

super(ForgetGate,self).__init__()

self.Wf=nn.Linear(input_size+hidden_size,hidden_size)

self.Uf=nn.Linear(hidden_size,hidden_size)

defforward(self,x,h_prev):

#遗忘门的sigmoid层

f_t=torch.sigmoid(self.Wf(torch.cat([x,h_prev],dim=1))+self.Uf(h_prev))

returnf_t1.1.3输出门（OutputGate）输出门决定哪些信息将从记忆单元中被读出。它由一个sigmoid层和一个tanh层组成。sigmoid层决定哪些记忆单元的值将被输出，tanh层将记忆单元的值压缩到-1到1之间，然后与sigmoid层的输出相乘，产生最终的输出。#PyTorch实现LSTM输出门

classOutputGate(nn.Module):

def__init__(self,input_size,hidden_size):

super(OutputGate,self).__init__()

self.Wo=nn.Linear(input_size+hidden_size,hidden_size)

self.Uo=nn.Linear(hidden_size,hidden_size)

defforward(self,x,h_prev,c_next):

#输出门的sigmoid层

o_t=torch.sigmoid(self.Wo(torch.cat([x,h_prev],dim=1))+self.Uo(h_prev))

#计算最终输出

h_next=torch.mul(o_t,torch.tanh(c_next))

returnh_next1.1.4记忆单元（CellState）记忆单元是LSTM的核心，它存储了序列中的信息。通过输入门和遗忘门的控制，它可以有效地保留或丢弃信息，从而解决长期依赖问题。1.2LSTM网络的工作原理LSTM网络通过一系列的LSTM单元来处理序列数据。每个单元接收当前时间步的输入和上一时间步的隐藏状态与记忆单元状态，然后通过门控机制更新隐藏状态和记忆单元状态。1.2.1步骤遗忘门：决定哪些信息将从记忆单元中被遗忘。输入门：决定哪些信息将被存储到记忆单元中。记忆单元更新：根据遗忘门和输入门的输出，更新记忆单元。输出门：决定哪些信息将从记忆单元中被读出，产生当前时间步的输出。1.2.2示例假设我们有一个序列数据，每个时间步的输入是一个向量，我们使用LSTM网络来处理这个序列。#PyTorch实现LSTM网络

classLSTM(nn.Module):

def__init__(self,input_size,hidden_size):

super(LSTM,self).__init__()

self.input_gate=InputGate(input_size,hidden_size)

self.forget_gate=ForgetGate(input_size,hidden_size)

self.output_gate=OutputGate(input_size,hidden_size)

defforward(self,x,h_prev,c_prev):

#遗忘门

f_t=self.forget_gate(x,h_prev)

#输入门

c_next=self.input_gate(x,h_prev,c_prev)

#记忆单元更新

c_next=torch.mul(f_t,c_prev)+c_next

#输出门

h_next=self.output_gate(x,h_prev,c_next)

returnh_next,c_next

#创建LSTM网络实例

lstm=LSTM(input_size=100,hidden_size=50)

#假设序列数据

sequence_data=torch.randn(10,100)#10个时间步，每个时间步的输入是100维向量

#初始化隐藏状态和记忆单元状态

h_prev=torch.zeros(1,50)

c_prev=torch.zeros(1,50)

#处理序列数据

fortinrange(sequence_data.size(0)):

x_t=sequence_data[t].unsqueeze(0)

h_prev,c_prev=lstm(x_t,h_prev,c_prev)在这个示例中，我们创建了一个LSTM网络，它接收100维的输入向量，并有50维的隐藏状态。我们使用随机生成的序列数据来演示LSTM网络如何处理序列信息。通过循环遍历序列数据的每个时间步，LSTM网络更新其隐藏状态和记忆单元状态，从而处理序列信息。LSTM网络通过其独特的门控机制，能够有效地处理长期依赖问题，使得网络在处理序列数据时具有更好的性能。在实际应用中，LSTM网络被广泛用于自然语言处理、语音识别、时间序列预测等领域。2优化LSTM网络2.1解决梯度消失与梯度爆炸问题2.1.1梯度消失与梯度爆炸的原理在训练深度神经网络时，尤其是像LSTM这样的循环神经网络，可能会遇到梯度消失或梯度爆炸的问题。这些问题源于反向传播算法在计算梯度时，随着网络深度的增加，梯度可能变得非常小（梯度消失）或非常大（梯度爆炸），导致网络学习缓慢或不稳定。梯度消失梯度消失通常发生在网络的早期层，当梯度在反向传播过程中逐渐减小，导致这些层的权重更新非常缓慢，网络可能无法学习到重要的特征。梯度爆炸梯度爆炸则是在反向传播过程中，梯度变得异常大，这可能导致权重更新过大，使得网络学习不稳定，甚至发散。2.1.2解决梯度消失与梯度爆炸的技巧使用门控机制LSTM通过引入门控机制（输入门、遗忘门、输出门）来控制信息的流动，这有助于缓解梯度消失问题。门控机制允许网络选择性地记住或遗忘信息，从而在长序列中保持有效的梯度。梯度裁剪梯度裁剪是一种防止梯度爆炸的策略，它通过限制梯度的大小，确保其不会变得过大。具体做法是，如果梯度的范数超过某个阈值，就按比例缩小梯度。#梯度裁剪示例代码

importtorch

fromtorchimportnn

fromtorch.nn.utilsimportclip_grad_norm_

#定义模型

model=nn.LSTM(input_size=10,hidden_size=20,num_layers=2)

#定义损失函数和优化器

criterion=nn.CrossEntropyLoss()

optimizer=torch.optim.Adam(model.parameters(),lr=0.001)

#假设输入和目标数据

inputs=torch.randn(5,3,10)#序列长度为5，批量大小为3，输入维度为10

targets=torch.randint(0,20,(5,3))#目标数据，与输入相同长度和批量大小

#前向传播

outputs,(hidden,cell)=model(inputs)

loss=criterion(outputs.view(-1,20),targets.view(-1))

#反向传播

loss.backward()

#梯度裁剪

clip_grad_norm_(model.parameters(),max_norm=1)

#更新权重

optimizer.step()初始化权重适当的权重初始化可以避免梯度消失或爆炸。例如，使用正交初始化或Xavier初始化可以保持梯度的稳定。#权重初始化示例代码

importtorch.nn.initasinit

#初始化模型的权重

forname,paramind_parameters():

if'weight'inname:

init.orthogonal_(param)

elif'bias'inname:

init.constant_(param,0)2.2使用Dropout防止过拟合2.2.1Dropout的原理Dropout是一种正则化技术，用于防止神经网络过拟合。在训练过程中，随机选择一部分神经元并将其输出设置为0，这相当于在每次迭代中使用不同的网络结构，增加了模型的泛化能力。2.2.2Dropout在LSTM中的应用在LSTM中，Dropout可以应用于输入层、输出层以及隐藏层之间的连接。这有助于减少LSTM单元之间的依赖，提高模型的鲁棒性。#使用Dropout的LSTM模型示例代码

importtorch.nnasnn

classLSTMWithDropout(nn.Module):

def__init__(self,input_size,hidden_size,num_layers,dropout):

super(LSTMWithDropout,self).__init__()

self.lstm=nn.LSTM(input_size,hidden_size,num_layers,dropout=dropout)

self.dropout=nn.Dropout(dropout)

defforward(self,x):

x=self.dropout(x)

outputs,(hidden,cell)=self.lstm(x)

returnoutputs,(hidden,cell)

#定义模型

model=LSTMWithDropout(input_size=10,hidden_size=20,num_layers=2,dropout=0.5)2.2.3Dropout的注意事项选择合适的Dropout率：Dropout率过高可能导致模型欠拟合，过低则可能无法有效防止过拟合。仅在训练时使用Dropout：在模型评估或预测时，应关闭Dropout，以确保模型的输出稳定。通过上述技巧，可以显著提高LSTM网络的训练效率和模型性能，避免常见的训练问题，使模型在处理序列数据时更加稳定和有效。3高级优化技巧3.1批量归一化在LSTM中的应用批量归一化（BatchNormalization,BN）是一种用于加速深度神经网络训练的技术，通过归一化网络层的输入，减少内部协变量偏移（InternalCovariateShift），从而使得网络训练更加稳定和快速。在LSTM网络中，由于其复杂的门控机制，批量归一化可以进一步帮助网络学习更有效的长期依赖关系。3.1.1原理批量归一化在每个mini-batch上对数据进行归一化，使得每一层的输入具有零均值和单位方差。具体步骤如下：计算均值和方差：对于每个mini-batch，计算输入数据的均值和方差。归一化：使用计算出的均值和方差对输入数据进行归一化。缩放和偏移：通过可学习参数γ（缩放）和β（偏移）对归一化后的数据进行缩放和偏移，以保持网络的表达能力。3.1.2代码示例假设我们使用Keras库构建一个LSTM模型，并在LSTM层前应用批量归一化。importnumpyasnp

fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,BatchNormalization,Dense

#生成模拟数据

data=np.random.rand(1000,10,1)

labels=np.random.randint(2,size=(1000,1))

#构建模型

model=Sequential()

model.add(BatchNormalization(input_shape=(10,1)))

model.add(LSTM(32,return_sequences=True))

model.add(BatchNormalization())

model.add(LSTM(32))

model.add(Dense(1,activation='sigmoid'))

#编译模型

pile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])

#训练模型

model.fit(data,labels,epochs=10,batch_size=32)3.1.3解释在上述代码中，我们首先生成了1000个样本的模拟数据，每个样本包含10个时间步长，每个时间步长有1个特征。然后，我们构建了一个包含两个LSTM层的序列模型，每个LSTM层前都添加了批量归一化层。最后，我们编译并训练了模型。3.2学习率调整策略学习率是深度学习模型训练中的关键超参数，它控制着权重更新的幅度。一个固定的学习率可能在训练初期收敛过快，而在后期收敛过慢。因此，动态调整学习率可以提高模型的训练效率和性能。3.2.1原理学习率调整策略包括但不限于：学习率衰减：随着训练的进行，逐渐减小学习率。学习率回弹：在训练过程中周期性地调整学习率，以帮助模型跳出局部最小值。基于验证集的学习率调整：根据验证集上的性能调整学习率，当性能不再提高时，减小学习率。3.2.2代码示例使用Keras的ReduceLROnPlateau回调函数，根据验证集的损失动态调整学习率。fromkeras.callbacksimportReduceLROnPlateau

#定义学习率调整策略

lr_reduce=ReduceLROnPlateau(monitor='val_loss',factor=0.2,patience=5,verbose=1,min_lr=0.0001)

#训练模型，同时应用学习率调整策略

model.fit(data,labels,epochs=100,batch_size=32,callbacks=[lr_reduce],validation_split=0.2)3.2.3解释在代码示例中，我们定义了一个ReduceLROnPlateau回调，它监控验证集的损失（val_loss）。当验证集的损失在连续5个epoch内没有改善时，学习率将被减小到原来的20%。此外，我们设置了学习率的最小值为0.0001，以防止学习率过小导致训练停滞。通过上述代码，我们可以在训练LSTM模型时，根据验证集的性能动态调整学习率，从而优化模型的训练过程。4深度学习：长短期记忆网络（LSTM）：LSTM网络的调参艺术4.1选择合适的隐藏层单元数在构建LSTM模型时，选择隐藏层单元数是一个关键的决策点。隐藏层单元数直接影响模型的复杂度和学习能力。单元数过多可能导致过拟合，而过少则可能使模型无法捕捉到数据中的复杂模式。4.1.1原理LSTM单元数（也称为神经元数）决定了模型能够记住的信息量。每个单元可以被视为一个记忆单元，用于存储序列中的信息。更多的单元意味着模型可以存储更多的信息，但也意味着更多的参数需要学习，这可能会增加训练时间和计算资源的需求。4.1.2实践为了选择合适的隐藏层单元数，可以采用交叉验证的方法。通过在不同的单元数设置下训练模型，并在验证集上评估性能，可以找到最佳的单元数。以下是一个使用Keras库在Python中实现的例子：importnumpyasnp

fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,Dense

fromkeras.wrappers.scikit_learnimportKerasRegressor

fromsklearn.model_selectionimportGridSearchCV

#数据准备

X=np.random.rand(1000,10,1)

y=np.random.rand(1000,1)

#构建模型函数

defcreate_model(neurons=1):

model=Sequential()

model.add(LSTM(neurons,input_shape=(10,1)))

model.add(Dense(1))

pile(loss='mean_squared_error',optimizer='adam')

returnmodel

#将Keras模型转换为Scikit-Learn的模型

model=KerasRegressor(build_fn=create_model,verbose=0)

#定义网格搜索参数

neurons=[10,20,30,40,50]

param_grid=dict(neurons=neurons)

#执行网格搜索

grid=GridSearchCV(estimator=model,param_grid=param_grid,n_jobs=-1)

grid_result=grid.fit(X,y)

#输出最佳参数

print("Best:%fusing%s"%(grid_result.best_score_,grid_result.best_params_))在这个例子中，我们使用了GridSearchCV来自动搜索最佳的神经元数。通过比较不同设置下的模型性能，我们可以找到最适合我们数据集的隐藏层单元数。4.2优化序列长度序列长度是LSTM模型中的另一个重要参数，它决定了模型在做出预测时考虑的输入序列的长度。优化序列长度可以帮助模型更好地捕捉时间序列中的模式。4.2.1原理序列长度的选择影响模型对时间依赖性的学习。较长的序列长度可以让模型学习到更远的依赖关系，但同时也可能引入噪声，使模型学习到不相关的数据。此外，较长的序列会增加训练时间。4.2.2实践优化序列长度可以通过实验不同的长度并评估模型性能来实现。以下是一个使用Python和Keras库调整序列长度的例子：#数据准备

X=np.random.rand(1000,50,1)

y=np.random.rand(1000,1)

#构建模型函数

defcreate_model(timesteps=1):

model=Sequential()

model.add(LSTM(50,input_shape=(timesteps,1)))

model.add(Dense(1))

pile(loss='mean_squared_error',optimizer='adam')

returnmodel

#定义不同的序列长度

timesteps=[10,20,30,40,50]

#评估不同序列长度下的模型性能

fortsintimesteps:

model=create_model(ts)

model.fit(X[:,:ts,:],y,epochs=10,batch_size=32,verbose=0)

score=model.evaluate(X[:,:ts,:],y,verbose=0)

print("SequenceLength:%d,Score:%.2f"%(ts,score))在这个例子中，我们通过改变输入数据的序列长度来评估模型的性能。通过比较不同序列长度下的得分，我们可以确定哪个长度最适合我们的数据集。通过以上两个部分的实践，我们可以更有效地调整LSTM模型的参数，以提高其在特定任务上的性能。选择合适的隐藏层单元数和优化序列长度是LSTM网络调参艺术中的两个重要技巧。5实战案例分析5.1文本生成中的LSTM优化在文本生成任务中，长短期记忆网络（LSTM）因其能够处理长序列依赖的能力而被广泛采用。然而，LSTM网络在训练过程中可能会遇到梯度消失或梯度爆炸的问题，导致模型性能不佳。以下是一些优化技巧，以及如何在文本生成任务中应用这些技巧的示例。5.1.1使用Dropout正则化Dropout是一种正则化技术，通过在训练过程中随机“丢弃”一部分神经元，可以防止模型过拟合。在LSTM中，通常在输入和输出层应用Dropout。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,Dropout,Dense

model=Sequential()

model.add(LSTM(128,input_shape=(None,vocab_size),return_sequences=True))

model.add(Dropout(0.5))

model.add(LSTM(128))

model.add(Dropout(0.5))

model.add(Dense(vocab_size,activation='softmax'))

pile(loss='categorical_crossentropy',optimizer='adam')5.1.2梯度裁剪梯度裁剪是一种防止梯度爆炸的策略，通过限制梯度的大小，确保模型训练的稳定性。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,Dense

fromkerasimportoptimizers

clipvalue=0.5

clipnorm=1.0

adam=optimizers.Adam(clipvalue=clipvalue,clipnorm=clipnorm)

model=Sequential()

model.add(LSTM(128,input_shape=(None,vocab_size)))

model.add(Dense(vocab_size,activation='softmax'))

pile(loss='categorical_crossentropy',optimizer=adam)5.1.3使用BatchNormalizationBatchNormalization可以加速模型的训练过程，并有助于提高模型的性能。在LSTM中，通常在LSTM层之后应用BatchNormalization。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,BatchNormalization,Dense

model=Sequential()

model.add(LSTM(128,input_shape=(None,vocab_size),return_sequences=True))

model.add(BatchNormalization())

model.add(LSTM(128))

model.add(BatchNormalization())

model.add(Dense(vocab_size,activation='softmax'))

pile(loss='categorical_crossentropy',optimizer='adam')5.1.4调整学习率学习率是模型训练过程中的关键参数。过高或过低的学习率都可能导致模型训练效果不佳。使用学习率衰减或自适应学习率算法（如Adam、RMSprop）可以提高模型的训练效果。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,Dense

fromkerasimportoptimizers

learning_rate=0.001

decay_rate=learning_rate/100

adam=optimizers.Adam(lr=learning_rate,decay=decay_rate)

model=Sequential()

model.add(LSTM(128,input_shape=(None,vocab_size)))

model.add(Dense(vocab_size,activation='softmax'))

pile(loss='categorical_crossentropy',optimizer=adam)5.2时间序列预测的LSTM调优时间序列预测是LSTM网络的另一个重要应用领域。在处理时间序列数据时，LSTM网络可以捕捉到数据中的长期依赖关系。然而，时间序列预测的LSTM网络同样需要进行优化，以提高预测的准确性。5.2.1使用双向LSTM双向LSTM可以同时考虑序列的过去和未来信息，从而提高模型的预测能力。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportBidirectional,LSTM,Dense

model=Sequential()

model.add(Bidirectional(LSTM(128),input_shape=(None,input_dim)))

model.add(Dense(1))

pile(loss='mean_squared_error',optimizer='adam')5.2.2增加隐藏层增加LSTM网络的隐藏层数量可以提高模型的复杂度，从而提高模型的预测能力。但同时，过多的隐藏层也可能导致过拟合。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,Dense

model=Sequential()

model.add(LSTM(128,input_shape=(None,input_dim),return_sequences=True))

model.add(LSTM(128))

model.add(Dense(1))

pile(loss='mean_squared_error',optimizer='adam')5.2.3使用不同的激活函数LSTM网络中的激活函数对模型的性能有重要影响。尝试使用不同的激活函数，如tanh、ReLU或LeakyReLU，可以提高模型的预测能力。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,Dense

model=Sequential()

model.add(LSTM(128,input_shape=(None,input_dim),activation='relu'))

model.add(Dense(1))

pile(loss='mean_squared_error',optimizer='adam')5.2.4数据预处理对时间序列数据进行预处理，如归一化、标准化或差分，可以提高模型的预测能力。示例代码importnumpyasnp

fromsklearn.preprocessingimportMinMaxScaler

#数据预处理

scaler=MinMaxScaler(feature_range=(0,1))

data=scaler.fit_transform(data)

#构建训练数据集

X,y=[],[]

foriinrange(len(data)-timesteps-1):

X.append(data[i:(i+timesteps),0])

y.append(data[i+timesteps,0])

X,y=np.array(X),np.array(y)

#重塑输入数据为3D格式

X=np.reshape(X,(X.shape[0],X.shape[1],1))5.2.5早停法（EarlyStopping）早停法是一种防止过拟合的策略，通过在验证集上监控模型的性能，当模型的性能不再提高时，停止训练。示例代码fromkeras.modelsimportSequential

fromkeras.layersimportLSTM,Dense

fromkeras.callbacksimportEarlyStopping

model=Sequential()

model.add(LSTM(128,input_shape=(None,input_dim)))

model.add(Dense(1))

pile(loss='mean_squared_error',optimizer='adam')

#定义早停法

early_stopping=EarlyStopping(monitor='val_loss',patience=10)

#训练模型

model.fit(X_train,y_train,epochs=100,batch_size=32,validation_data=(X_val,y_val),callbacks=[early_stopping])通过上述优化技巧，可以显著提高LSTM网络在文本生成和时间序列预测任务中的性能。在实际应用中，可能需要尝试不同的组合，以找到最适合特定任务的优化策略。6LSTM与其它RNN变体的比较6.1GRU网络的优化特点6.1.1门控机制简化原理:GRU（门控循环单元）网络是LSTM的一种简化变体，它将LSTM中的输入门、输出门和遗忘门简化为两个门控机制：更新门（UpdateGate）和重置门（ResetGate）。这种简化不仅减少了网络的参数数量，还提高了训练速度，同时保持了处理长序列数据的能力。内容:-更新门(z)控制当前时刻的输出与前一时刻的隐藏状态之间的线性插值。-重置门(r)控制前一时刻的隐藏状态对当前时刻的候选隐藏状态的影响程度。6.1.2参数减少原理:由于GRU网络的门控机制简化，它使用较少的参数来实现与LSTM相似的功能。这使得GRU网络在训练时更加高效，减少了过拟合的风险。内容:-GRU网络的参数量大约是LSTM的一半，因为GRU合并了LSTM的输入门和遗忘门，只保留了更新门和重置门。6.1.3训练速度提升原理:GRU网络的简化结构和较少的参数量使得其在训练过程中计算速度更快，尤其是在处理长序列数据时。内容:-在相同的硬件和数据集上，GRU网络通常比LSTM网络训练得更快。6.1.4性能接近LSTM原理:尽管GRU网络在结构上进行了简化，但在许多任务上，它的性能与LSTM网络相当，甚至在某些情况下优于LSTM。内容:-GRU网络在语音识别、机器翻译和文本生成等任务上表现出了与LSTM网络相似或更好的性能。6.1.5代码示例importnumpyasnp

importtensorflowastf

fromtensorflow.keras.modelsimportSequential

fromtensorflow.keras.layersimportGRU,Dense

#创建一个简单的GRU模型

model=Sequential()

model.add(GRU(32,input_shape=(10,50)))#假设输入序列长度为10，每个时间步的特征数为50

model.add(Dense(1,activation='sigmoid'))

#编译模型

pile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])

#生成模拟数据

x_train=np.random.random((1000,10,50))

y_train=