model.py 文件源码

def define_sequence_model(self):
      seed=12345
      np.random.seed(12345)
      layer_list=[]
      with self.graph.as_default() as g:
          utt_length=tf.placeholder(tf.int32,shape=(None))
          g.add_to_collection(name="utt_length",value=utt_length)
          with tf.name_scope("input"):
               input_layer=tf.placeholder(dtype=tf.float32,shape=(None,None,self.n_in),name="input_layer")
               if self.dropout_rate!=0.0:
                  print "Using dropout to avoid overfitting and the dropout rate is",self.dropout_rate
                  is_training_drop=tf.placeholder(dtype=tf.bool,shape=(),name="is_training_drop")
                  input_layer_drop=dropout(input_layer,self.dropout_rate,is_training=is_training_drop)
                  layer_list.append(input_layer_drop)
                  g.add_to_collection(name="is_training_drop",value=is_training_drop)
               else:
                  layer_list.append(input_layer)
          g.add_to_collection("input_layer",layer_list[0])
          with tf.name_scope("hidden_layer"):
             basic_cell=[]
             if "tanh" in self.hidden_layer_type:
                 is_training_batch=tf.placeholder(dtype=tf.bool,shape=(),name="is_training_batch")
                 bn_params={"is_training":is_training_batch,"decay":0.99,"updates_collections":None}
                 g.add_to_collection("is_training_batch",is_training_batch)
             for i in xrange(len(self.hidden_layer_type)):
                 if self.dropout_rate!=0.0:
                     if self.hidden_layer_type[i]=="tanh":
                         new_layer=fully_connected(layer_list[-1],self.hidden_layer_size[i],activation_fn=tf.nn.tanh,normalizer_fn=batch_norm,normalizer_params=bn_params)
                         new_layer_drop=dropout(new_layer,self.dropout_rate,is_training=is_training_drop)
                         layer_list.append(new_layer_drop)
                     if self.hidden_layer_type[i]=="lstm":
                         basic_cell.append(MyDropoutWrapper(BasicLSTMCell(num_units=self.hidden_layer_size[i]),self.dropout_rate,self.dropout_rate,is_training=is_training_drop))
                     if self.hidden_layer_type[i]=="gru":
                         basic_cell.append(MyDropoutWrapper(GRUCell(num_units=self.hidden_layer_size[i]),self.dropout_rate,self.dropout_rate,is_training=is_training_drop))
                 else:
                     if self.hidden_layer_type[i]=="tanh":
                        new_layer=fully_connected(layer_list[-1],self.hidden_layer_size[i],activation_fn=tf.nn.tanh,normalizer_fn=batch_norm,normalizer_params=bn_params)
                        layer_list.append(new_layer)
                     if self.hidden_layer_type[i]=="lstm":
                        basic_cell.append(LayerNormBasicLSTMCell(num_units=self.hidden_layer_size[i]))
                     if self.hidden_layer_type[i]=="gru":
                        basic_cell.append(LayerNormGRUCell(num_units=self.hidden_layer_size[i]))
             multi_cell=MultiRNNCell(basic_cell)
             rnn_outputs,rnn_states=tf.nn.dynamic_rnn(multi_cell,layer_list[-1],dtype=tf.float32,sequence_length=utt_length)
             layer_list.append(rnn_outputs)
          with tf.name_scope("output_layer"):
               if self.output_type=="linear" :
                   output_layer=tf.layers.dense(rnn_outputs,self.n_out)
                #  stacked_rnn_outputs=tf.reshape(rnn_outputs,[-1,self.n_out])
                #  stacked_outputs=tf.layers.dense(stacked_rnn_outputs,self.n_out)
                #  output_layer=tf.reshape(stacked_outputs,[-1,utt_length,self.n_out])
               g.add_to_collection(name="output_layer",value=output_layer)
          with tf.name_scope("training_op"):
               if self.optimizer=="adam":
                   self.training_op=tf.train.AdamOptimizer()