纳米尺寸Theano LSTM模块
theano-lstm的Python项目详细描述
小的Theano LSTM递归网络模块
——SE类型的网络。
\ios隐藏激活，具有初始隐藏激活
*一个递归的**lstm层**，该层将其先前的隐藏激活和内存单元值作为输入，并且具有这两个值的初始值
*一个包含嵌入矩阵并以整数作为输入的**嵌入**层并返回嵌入矩阵（例如字向量）的切片
*一个非递归的**gatedinput**，带有连接矩阵w和bias b，它将单个标量乘以每个输入（联合选通多个输入）
*处理具有次梯度优化的爆炸和消失梯度。zer（adadelta）和元素级梯度裁剪（ala alex graves）
此模块还包含使用目标函数和一组变量构造的**sgd**、**adagrad**和**adadelta**梯度下降方法，并返回要传递到的"updates"字典。a theano函数。
使用堆叠的LSTM单元，使用ADADLTA进行优化，并使用ANO的扫描操作（通过时间反向传播的符号循环）。
model=stackedcell（4，layers=[20，20]，activation=t.tanh，celltype=lstm）
model.layers[0].in_gate2.activation=lambda x:x
model.layers.append（layer（20，2，lambda x:t.nnet.softmax（x）[0]）
_状态=堆叠的向前（x，前一个隐藏，退出）
返回[动力学（x，新的状态[-1]）]+新的状态[：-1]
为模型中的层输出_info=[dict（initial=initial_obs，taps=[-1]）+[dict（initial=layer.initial_hidden_state，taps=[-1]）（如果hasatt（layer，'initial_hidden_state'）））
target=t.vector（）
cost=（result[0][：，[0,2]]-target[[0,2]]）.norm（l=2）/timesteps
updates、gsums、xsums、lr、max-norm=\
创建优化更新（cost、model.params、method='adadelta'）
update-fun=theano.function（[初始obs、目标、时间步]、cost、updates=updates、allow-input-downcast=true）
predict-fun=theano.function（[初始obs、timestps），result[0]，allow_input_downcast=true）
例如，training_set中的label：
c=update_fun（例如label，10）
然后可以分批进行训练：
model=stackedcell（4，layers=[20，20]，activation=t.tanh，celltype=lstm）
model.layers[0].in_gate2.activation=lambda x:x
model.layers.append（layer（20，2，lambda x:t.nnet.softmax（x）[0]）
它模拟了双摆的行为，得到了我们当前的状态，并对t+1进行了观察。定义动力学（x，u）：
dydx=t.alloc（0.0，4）
dydx=t.set子传感器（dydx[0]，x[1]）
dydx=t.set子传感器（dydx[0]，x[0]，x[1]）
del=x[2]-x[0]
de n 1=（m1+m2）*l1*m2*l1*t.cos（del*t.cos（del*t.cos（del）*t.cos（del*t.cos（del
dydx=t.set子传感器（dydx[1]，[1]，\n"，
（m2 1]*t.sin（德l_t.cos（del_）
+m2*g*t.sin（x[2]）*t.cos（del_）+
m2*l2*x[3]*x[3]*t.sin（del_）
-（m1+m2）*g*t.sin（x[0]）/den1）
dydx=t.set懔subsensor（dydx[2]，x[3]）
den2=（l2/l1）*den1
dydX=T.SETU子传感器（DYDX[3]，（-m2*L2*X[3]*X[3]*T.sin（del_）*T.cos（del_）T.cos（del_）
+（M1+M2）*（M1+M2）**G*T.sin（X[0]）*T.cos（del_）
-（M1+M2）*（M1+M2）*（M1+M2）**L1*X[1]*X[1]*T.sin（del_）T.sin（del（M1+M2）*（M1+M2）*（M1+M2）*（M1+M2）**L1*X[X[1]*X[1]*X[1]*是的*dt
def step（x，*前一个隐藏）：
新的状态=堆叠的前向（x，前一个隐藏，退出）
返回[动态（x，新的状态[-1]）+新的状态[：-1]
切换到观察矩阵：
初始obs=t.imatrix（）
时间步=t.iscalar（）
t，updates=theano.scan（步骤，
n_steps=timesteps，
输出信息=[dict（initial=initial obs，taps=[-1]）]+[dict（initial=layer.initial_hidden_state，taps=[-1]）用于模型中的层。layers if hasattr（layer，'initial_hidden_state'）））
target=t.ivector（）
cost=（result[0][：，：，[0,2]]-target[：，[0,2]]）.norm（l=2）/timesteps
updates，gsums，xsums，lr，max-norm=\
创建优化更新（cost，model.params，method='adadelta'）
update fun=theano.function（[初始obs，target，timesteps]，cost，updates=updates，allow_input_downcast=true）
predict_fun=theano.function（[初始OBS，时间步长]，结果[0]，allow_input_downcast=true）
/>
如果我们接受不关心的图的前向传播部分的较小代价，则可以对不同的序列长度进行泛化。为此，我们用一些符号填充较短序列的末尾，使所有序列的长度相同。然后使用与所有小批量序列大小相同的二进制矩阵。当计算误差时，矩阵的面积为1，否则为零。将这个掩码与您的输出进行元素交互，然后将您的目标函数应用于这个掩码输出。在任何地方都会得到错误，但在被屏蔽的区域都将为零，从而产生正确的错误函数。
虽然存在一些浪费的计算，但并行化可以抵消此成本，并使整体计算更快。
NT长度序列，考虑以下方法：
*您有序列*y_1，y_2，…，y_n*和标签*l_1，l_2，…，l_n*
*将所有序列填充到最长序列*y_k*，并形成所有填充序列的矩阵**y**
*类似地在每个时间步形成标签每个填充序列（带零，或填充区域中标签的其他符号）
*然后记录填充前所需的真实标签（代码长度）的长度*c_1，c_2，…，c_n*，以及填充前序列的长度*l_1，l_2，…，l_n*
*传递长度、目标和pred对屏蔽损耗的操作如下：
predictions，updates=theano.scan（prediction_step等）
padded_labels，
codelengs，
label_starts）.mean（）
这在视觉上是可行的类似于这样，对于有三个输入、三个输出，但只有一个标签用于
最终输出：
inputs[x_1 x_2 x_3]
outputs[p_2 p_3]
标签[……l_1]
然后我们将得到一个矩阵*x*，上面的代码中有*x_1，x_2，x_3*，并且"预测"将包含*p_1，p_2，p_3*
然后我们将代码长度[1]传递给"屏蔽的"丢失，因为只有"l_1"可以预测，而"标签"开始于`[2]，
表示错误应该在第三次预测时计算（0 index）。
no扫描中的退出用法
onfig.floatx））
deterministic=false；现在
要在"扫描"循环外使用dropout，您可以简单地用一个二项式随机变量（参见这里的示例）（https://gist.github.com/snippyhollow/8a0f820261926e2f41cc））乘以元素，但是如果您计划使用带有"扫描"循环的递归网络，则需要在循环外调用您的随机数。
我们将生成*masks*的退出激活。*掩码*是一个包含所有二项式实现的列表。我们使用"multidropout"生成这个列表，这是"theano_lsm"模块中的一个特殊函数，它接受不同的隐藏层大小，并返回一个包含二项式随机变量实现的矩阵列表：
r/>掩码=[np.float32（1.）-self.dropout for i in range（2）]
其他：
形状=[50，100]
掩码=不存在多个dropout（[（x.shape[0]，shape）用于形状]if x.ndim>；1其他形状，
self.dropout）
其他：
masks=[]
现在我们的循环转发函数如下：
def step（obs，hidden_state，*masks）：
new_state=model.forward（obs，[hidden_state]，list（masks））
返回new_state[1]
我们将其传递给节点的扫描：
结果，u=theano.scan（step，
序列=seq，
非sequences=masks，
输出_info=[dict（initial=model.layers[0].initial_hidden_state，taps=[-1]）]
）
我们完成了。
**注意：**不使用*masks*传递空列表`[]。
——SE类型的网络。
\ios隐藏激活，具有初始隐藏激活
*一个递归的**lstm层**，该层将其先前的隐藏激活和内存单元值作为输入，并且具有这两个值的初始值
*一个包含嵌入矩阵并以整数作为输入的**嵌入**层并返回嵌入矩阵（例如字向量）的切片
*一个非递归的**gatedinput**，带有连接矩阵w和bias b，它将单个标量乘以每个输入（联合选通多个输入）
*处理具有次梯度优化的爆炸和消失梯度。zer（adadelta）和元素级梯度裁剪（ala alex graves）
此模块还包含使用目标函数和一组变量构造的**sgd**、**adagrad**和**adadelta**梯度下降方法，并返回要传递到的"updates"字典。a theano函数。
使用堆叠的LSTM单元，使用ADADLTA进行优化，并使用ANO的扫描操作（通过时间反向传播的符号循环）。
model=stackedcell（4，layers=[20，20]，activation=t.tanh，celltype=lstm）
model.layers[0].in_gate2.activation=lambda x:x
model.layers.append（layer（20，2，lambda x:t.nnet.softmax（x）[0]）
_状态=堆叠的向前（x，前一个隐藏，退出）
返回[动力学（x，新的状态[-1]）]+新的状态[：-1]
为模型中的层输出_info=[dict（initial=initial_obs，taps=[-1]）+[dict（initial=layer.initial_hidden_state，taps=[-1]）（如果hasatt（layer，'initial_hidden_state'）））
target=t.vector（）
cost=（result[0][：，[0,2]]-target[[0,2]]）.norm（l=2）/timesteps
updates、gsums、xsums、lr、max-norm=\
创建优化更新（cost、model.params、method='adadelta'）
update-fun=theano.function（[初始obs、目标、时间步]、cost、updates=updates、allow-input-downcast=true）
predict-fun=theano.function（[初始obs、timestps），result[0]，allow_input_downcast=true）
例如，training_set中的label：
c=update_fun（例如label，10）
然后可以分批进行训练：
model=stackedcell（4，layers=[20，20]，activation=t.tanh，celltype=lstm）
model.layers[0].in_gate2.activation=lambda x:x
model.layers.append（layer（20，2，lambda x:t.nnet.softmax（x）[0]）
它模拟了双摆的行为，得到了我们当前的状态，并对t+1进行了观察。定义动力学（x，u）：
dydx=t.alloc（0.0，4）
dydx=t.set子传感器（dydx[0]，x[1]）
dydx=t.set子传感器（dydx[0]，x[0]，x[1]）
del=x[2]-x[0]
de n 1=（m1+m2）*l1*m2*l1*t.cos（del*t.cos（del*t.cos（del）*t.cos（del*t.cos（del
dydx=t.set子传感器（dydx[1]，[1]，\n"，
（m2 1]*t.sin（德l_t.cos（del_）
+m2*g*t.sin（x[2]）*t.cos（del_）+
m2*l2*x[3]*x[3]*t.sin（del_）
-（m1+m2）*g*t.sin（x[0]）/den1）
dydx=t.set懔subsensor（dydx[2]，x[3]）
den2=（l2/l1）*den1
dydX=T.SETU子传感器（DYDX[3]，（-m2*L2*X[3]*X[3]*T.sin（del_）*T.cos（del_）T.cos（del_）
+（M1+M2）*（M1+M2）**G*T.sin（X[0]）*T.cos（del_）
-（M1+M2）*（M1+M2）*（M1+M2）**L1*X[1]*X[1]*T.sin（del_）T.sin（del（M1+M2）*（M1+M2）*（M1+M2）*（M1+M2）**L1*X[X[1]*X[1]*X[1]*是的*dt
def step（x，*前一个隐藏）：
新的状态=堆叠的前向（x，前一个隐藏，退出）
返回[动态（x，新的状态[-1]）+新的状态[：-1]
切换到观察矩阵：
初始obs=t.imatrix（）
时间步=t.iscalar（）
t，updates=theano.scan（步骤，
n_steps=timesteps，
输出信息=[dict（initial=initial obs，taps=[-1]）]+[dict（initial=layer.initial_hidden_state，taps=[-1]）用于模型中的层。layers if hasattr（layer，'initial_hidden_state'）））
target=t.ivector（）
cost=（result[0][：，：，[0,2]]-target[：，[0,2]]）.norm（l=2）/timesteps
updates，gsums，xsums，lr，max-norm=\
创建优化更新（cost，model.params，method='adadelta'）
update fun=theano.function（[初始obs，target，timesteps]，cost，updates=updates，allow_input_downcast=true）
predict_fun=theano.function（[初始OBS，时间步长]，结果[0]，allow_input_downcast=true）
/>
如果我们接受不关心的图的前向传播部分的较小代价，则可以对不同的序列长度进行泛化。为此，我们用一些符号填充较短序列的末尾，使所有序列的长度相同。然后使用与所有小批量序列大小相同的二进制矩阵。当计算误差时，矩阵的面积为1，否则为零。将这个掩码与您的输出进行元素交互，然后将您的目标函数应用于这个掩码输出。在任何地方都会得到错误，但在被屏蔽的区域都将为零，从而产生正确的错误函数。
虽然存在一些浪费的计算，但并行化可以抵消此成本，并使整体计算更快。
NT长度序列，考虑以下方法：
*您有序列*y_1，y_2，…，y_n*和标签*l_1，l_2，…，l_n*
*将所有序列填充到最长序列*y_k*，并形成所有填充序列的矩阵**y**
*类似地在每个时间步形成标签每个填充序列（带零，或填充区域中标签的其他符号）
*然后记录填充前所需的真实标签（代码长度）的长度*c_1，c_2，…，c_n*，以及填充前序列的长度*l_1，l_2，…，l_n*
*传递长度、目标和pred对屏蔽损耗的操作如下：
predictions，updates=theano.scan（prediction_step等）
padded_labels，
codelengs，
label_starts）.mean（）
这在视觉上是可行的类似于这样，对于有三个输入、三个输出，但只有一个标签用于
最终输出：
inputs[x_1 x_2 x_3]
outputs[p_2 p_3]
标签[……l_1]
然后我们将得到一个矩阵*x*，上面的代码中有*x_1，x_2，x_3*，并且"预测"将包含*p_1，p_2，p_3*
然后我们将代码长度[1]传递给"屏蔽的"丢失，因为只有"l_1"可以预测，而"标签"开始于`[2]，
表示错误应该在第三次预测时计算（0 index）。
no扫描中的退出用法
onfig.floatx））
deterministic=false；现在
要在"扫描"循环外使用dropout，您可以简单地用一个二项式随机变量（参见这里的示例）（https://gist.github.com/snippyhollow/8a0f820261926e2f41cc））乘以元素，但是如果您计划使用带有"扫描"循环的递归网络，则需要在循环外调用您的随机数。
我们将生成*masks*的退出激活。*掩码*是一个包含所有二项式实现的列表。我们使用"multidropout"生成这个列表，这是"theano_lsm"模块中的一个特殊函数，它接受不同的隐藏层大小，并返回一个包含二项式随机变量实现的矩阵列表：
r/>掩码=[np.float32（1.）-self.dropout for i in range（2）]
其他：
形状=[50，100]
掩码=不存在多个dropout（[（x.shape[0]，shape）用于形状]if x.ndim>；1其他形状，
self.dropout）
其他：
masks=[]
现在我们的循环转发函数如下：
def step（obs，hidden_state，*masks）：
new_state=model.forward（obs，[hidden_state]，list（masks））
返回new_state[1]
我们将其传递给节点的扫描：
结果，u=theano.scan（step，
序列=seq，
非sequences=masks，
输出_info=[dict（initial=model.layers[0].initial_hidden_state，taps=[-1]）]
）
我们完成了。
**注意：**不使用*masks*传递空列表`[]。
欢迎加入QQ群-->： 979659372
