fix dynamic rnn error commit

Author: zsdonghao

tensorlayer/layers.py

@@ -3925,8 +3925,8 @@ def __init__(
         self.batch_size = batch_size
 
         # Creats the cell function
-        cell_instance_fn=lambda: cell_fn(num_units=n_hidden, **cell_init_args)
-        # self.cell = cell_fn(num_units=n_hidden, **cell_init_args)
+        # cell_instance_fn=lambda: cell_fn(num_units=n_hidden, **cell_init_args) # HanSheng
+        self.cell = cell_fn(num_units=n_hidden, **cell_init_args)
 
         # Apply dropout
         if dropout:
@@ -3943,34 +3943,35 @@ def __init__(
             except:
                 DropoutWrapper_fn = tf.nn.rnn_cell.DropoutWrapper
 
-            cell_instance_fn1=cell_instance_fn
-            cell_instance_fn=DropoutWrapper_fn(
-                                cell_instance_fn1(),
-                                input_keep_prob=in_keep_prob,
-                                output_keep_prob=out_keep_prob)
-            # self.cell = DropoutWrapper_fn(
-            #           self.cell,
-            #           input_keep_prob=in_keep_prob,
-            #           output_keep_prob=out_keep_prob)
+            # cell_instance_fn1=cell_instance_fn        # HanSheng
+            # cell_instance_fn=DropoutWrapper_fn(
+            #                     cell_instance_fn1(),
+            #                     input_keep_prob=in_keep_prob,
+            #                     output_keep_prob=out_keep_prob)
+            self.cell = DropoutWrapper_fn(
+                      self.cell,
+                      input_keep_prob=in_keep_prob,
+                      output_keep_prob=out_keep_prob)
         # Apply multiple layers
         if n_layer > 1:
             try:
                 MultiRNNCell_fn = tf.contrib.rnn.MultiRNNCell
             except:
                 MultiRNNCell_fn = tf.nn.rnn_cell.MultiRNNCell
 
-            cell_instance_fn2=cell_instance_fn
+            # cell_instance_fn2=cell_instance_fn # HanSheng
             try:
-                cell_instance_fn=lambda: MultiRNNCell_fn([cell_instance_fn2() for _ in range(n_layer)], state_is_tuple=True)
-                # self.cell = MultiRNNCell_fn([self.cell] * n_layer, state_is_tuple=True)
+                # cell_instance_fn=lambda: MultiRNNCell_fn([cell_instance_fn2() for _ in range(n_layer)], state_is_tuple=True) # HanSheng
+                self.cell = MultiRNNCell_fn([self.cell] * n_layer, state_is_tuple=True)
             except:
-                cell_instance_fn=lambda: MultiRNNCell_fn([cell_instance_fn2() for _ in range(n_layer)])
-                # self.cell = MultiRNNCell_fn([self.cell] * n_layer)
+                # cell_instance_fn=lambda: MultiRNNCell_fn([cell_instance_fn2() for _ in range(n_layer)]) # HanSheng
+                self.cell = MultiRNNCell_fn([self.cell] * n_layer)
+
+        # self.cell=cell_instance_fn() # HanSheng
 
-        self.cell=cell_instance_fn()
         # Initialize initial_state
         if initial_state is None:
-            self.initial_state = self.cell.zero_state(batch_size, dtype=tf.float32)#dtype="float")
+            self.initial_state = self.cell.zero_state(batch_size, dtype=tf.float32)
         else:
             self.initial_state = initial_state
 
@@ -4162,9 +4163,9 @@ def __init__(
 
         with tf.variable_scope(name, initializer=initializer) as vs:
             # Creats the cell function
-            cell_instance_fn=lambda: cell_fn(num_units=n_hidden, **cell_init_args)
-            # self.fw_cell = cell_fn(num_units=n_hidden, **cell_init_args)
-            # self.bw_cell = cell_fn(num_units=n_hidden, **cell_init_args)
+            # cell_instance_fn=lambda: cell_fn(num_units=n_hidden, **cell_init_args) # HanSheng
+            self.fw_cell = cell_fn(num_units=n_hidden, **cell_init_args)
+            self.bw_cell = cell_fn(num_units=n_hidden, **cell_init_args)
 
             # Apply dropout
             if dropout:
@@ -4181,33 +4182,33 @@ def __init__(
                 except:
                     DropoutWrapper_fn = tf.nn.rnn_cell.DropoutWrapper
 
-                    cell_instance_fn1=cell_instance_fn
-                    cell_instance_fn=lambda: DropoutWrapper_fn(
-                                        cell_instance_fn1(),
-                                        input_keep_prob=in_keep_prob,
-                                        output_keep_prob=out_keep_prob)
-
-                # self.fw_cell = DropoutWrapper_fn(
-                #     self.fw_cell,
-                #     input_keep_prob=in_keep_prob,
-                #     output_keep_prob=out_keep_prob)
-                # self.bw_cell = DropoutWrapper_fn(
-                #     self.bw_cell,
-                #     input_keep_prob=in_keep_prob,
-                #     output_keep_prob=out_keep_prob)
+                    # cell_instance_fn1=cell_instance_fn            # HanSheng
+                    # cell_instance_fn=lambda: DropoutWrapper_fn(
+                    #                     cell_instance_fn1(),
+                    #                     input_keep_prob=in_keep_prob,
+                    #                     output_keep_prob=out_keep_prob)
+
+                self.fw_cell = DropoutWrapper_fn(
+                    self.fw_cell,
+                    input_keep_prob=in_keep_prob,
+                    output_keep_prob=out_keep_prob)
+                self.bw_cell = DropoutWrapper_fn(
+                    self.bw_cell,
+                    input_keep_prob=in_keep_prob,
+                    output_keep_prob=out_keep_prob)
             # Apply multiple layers
             if n_layer > 1:
                 try:
                     MultiRNNCell_fn = tf.contrib.rnn.MultiRNNCell
                 except:
                     MultiRNNCell_fn = tf.nn.rnn_cell.MultiRNNCell
 
-                cell_instance_fn2=cell_instance_fn
-                cell_instance_fn=lambda: MultiRNNCell_fn([cell_instance_fn2() for _ in range(n_layer)])
-                # self.fw_cell = MultiRNNCell_fn([self.fw_cell] * n_layer)
-                # self.bw_cell = MultiRNNCell_fn([self.bw_cell] * n_layer)
-            self.fw_cell=cell_instance_fn()
-            self.bw_cell=cell_instance_fn()
+                # cell_instance_fn2=cell_instance_fn            # HanSheng
+                # cell_instance_fn=lambda: MultiRNNCell_fn([cell_instance_fn2() for _ in range(n_layer)])
+                self.fw_cell = MultiRNNCell_fn([self.fw_cell] * n_layer)
+                self.bw_cell = MultiRNNCell_fn([self.bw_cell] * n_layer)
+            # self.fw_cell=cell_instance_fn()
+            # self.bw_cell=cell_instance_fn()
             # Initial state of RNN
             if fw_initial_state is None:
                 self.fw_initial_state = self.fw_cell.zero_state(self.batch_size, dtype=tf.float32)