我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tensorflow.python.ops.rnn_cell.RNNCell()。
def basic_rnn_seq2seq( encoder_inputs, decoder_inputs, cell, dtype=dtypes.float32, scope=None): """Basic RNN sequence-to-sequence model. This model first runs an RNN to encode encoder_inputs into a state vector, then runs decoder, initialized with the last encoder state, on decoder_inputs. Encoder and decoder use the same RNN cell type, but don't share parameters. Args: encoder_inputs: A list of 2D Tensors [batch_size x input_size]. decoder_inputs: A list of 2D Tensors [batch_size x input_size]. cell: rnn_cell.RNNCell defining the cell function and size. dtype: The dtype of the initial state of the RNN cell (default: tf.float32). scope: VariableScope for the created subgraph; default: "basic_rnn_seq2seq". Returns: A tuple of the form (outputs, state), where: outputs: A list of the same length as decoder_inputs of 2D Tensors with shape [batch_size x output_size] containing the generated outputs. state: The state of each decoder cell in the final time-step. It is a 2D Tensor of shape [batch_size x cell.state_size]. """ with variable_scope.variable_scope(scope or "basic_rnn_seq2seq"): _, enc_state = rnn.rnn(cell, encoder_inputs, dtype=dtype) return rnn_decoder(decoder_inputs, enc_state, cell)
def apply_dropout( cell, input_keep_probability, output_keep_probability, random_seed=None): """Apply dropout to the outputs and inputs of `cell`. Args: cell: An `RNNCell`. input_keep_probability: Probability to keep inputs to `cell`. If `None`, no dropout is applied. output_keep_probability: Probability to keep outputs to `cell`. If `None`, no dropout is applied. random_seed: Seed for random dropout. Returns: An `RNNCell`, the result of applying the supplied dropouts to `cell`. """ input_prob_none = input_keep_probability is None output_prob_none = output_keep_probability is None if input_prob_none and output_prob_none: return cell if input_prob_none: input_keep_probability = 1.0 if output_prob_none: output_keep_probability = 1.0 return rnn_cell.DropoutWrapper( cell, input_keep_probability, output_keep_probability, random_seed)
def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0, seed=None, is_train=None): """Create a cell with added input and/or output dropout. Dropout is never used on the state. Args: cell: an RNNCell, a projection to output_size is added to it. input_keep_prob: unit Tensor or float between 0 and 1, input keep probability; if it is float and 1, no input dropout will be added. output_keep_prob: unit Tensor or float between 0 and 1, output keep probability; if it is float and 1, no output dropout will be added. seed: (optional) integer, the randomness seed. is_train: boolean tensor (often placeholder). If indicated, then when is_train is False, dropout is not applied. Raises: TypeError: if cell is not an RNNCell. ValueError: if keep_prob is not between 0 and 1. """ if not isinstance(cell, RNNCell): raise TypeError("The parameter cell is not a RNNCell.") if (isinstance(input_keep_prob, float) and not (input_keep_prob >= 0.0 and input_keep_prob <= 1.0)): raise ValueError("Parameter input_keep_prob must be between 0 and 1: %d" % input_keep_prob) if (isinstance(output_keep_prob, float) and not (output_keep_prob >= 0.0 and output_keep_prob <= 1.0)): raise ValueError("Parameter input_keep_prob must be between 0 and 1: %d" % output_keep_prob) self._cell = cell self._input_keep_prob = input_keep_prob self._output_keep_prob = output_keep_prob self._seed = seed self._is_train = is_train
def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0, seed=None, is_train=None): """Create a cell with added input and/or output dropout. Dropout is never used on the state. Args: cell: an RNNCell, a projection to output_size is added to it. input_keep_prob: unit Tensor or float between 0 and 1, input keep probability; if it is float and 1, no input dropout will be added. output_keep_prob: unit Tensor or float between 0 and 1, output keep probability; if it is float and 1, no output dropout will be added. seed: (optional) integer, the randomness seed. is_train: boolean tensor (often placeholder). If indicated, then when is_train is False, dropout is not applied. Raises: TypeError: if cell is not an RNNCell. ValueError: if keep_prob is not between 0 and 1. """ if not isinstance(cell, BiRNNCell): raise TypeError("The parameter cell is not a BiRNNCell.") if (isinstance(input_keep_prob, float) and not (input_keep_prob >= 0.0 and input_keep_prob <= 1.0)): raise ValueError("Parameter input_keep_prob must be between 0 and 1: %d" % input_keep_prob) if (isinstance(output_keep_prob, float) and not (output_keep_prob >= 0.0 and output_keep_prob <= 1.0)): raise ValueError("Parameter input_keep_prob must be between 0 and 1: %d" % output_keep_prob) self._cell = cell self._input_keep_prob = input_keep_prob self._output_keep_prob = output_keep_prob self._seed = seed self._is_train = is_train
def state_saving_rnn(cell, inputs, state_saver, state_name, sequence_length=None, scope=None): """RNN that accepts a state saver for time-truncated RNN calculation. Args: cell: An instance of RNNCell. inputs: A length T list of inputs, each a tensor of shape [batch_size, input_size]. state_saver: A state saver object with methods `state` and `save_state`. state_name: The name to use with the state_saver. sequence_length: (optional) An int32/int64 vector size [batch_size]. See the documentation for rnn() for more details about sequence_length. scope: VariableScope for the created subgraph; defaults to "RNN". Returns: A pair (outputs, state) where: outputs is a length T list of outputs (one for each input) states is the final state Raises: TypeError: If "cell" is not an instance of RNNCell. ValueError: If inputs is None or an empty list. """ initial_state = state_saver.state(state_name) (outputs, state) = rnn(cell, inputs, initial_state=initial_state, sequence_length=sequence_length, scope=scope) save_state = state_saver.save_state(state_name, state) with ops.control_dependencies([save_state]): outputs[-1] = array_ops.identity(outputs[-1]) return (outputs, state)
def tied_rnn_seq2seq(encoder_inputs, decoder_inputs, cell, loop_function=None, dtype=dtypes.float32, scope=None): """RNN sequence-to-sequence model with tied encoder and decoder parameters. This model first runs an RNN to encode encoder_inputs into a state vector, and then runs decoder, initialized with the last encoder state, on decoder_inputs. Encoder and decoder use the same RNN cell and share parameters. Args: encoder_inputs: A list of 2D Tensors [batch_size x input_size]. decoder_inputs: A list of 2D Tensors [batch_size x input_size]. cell: rnn_cell.RNNCell defining the cell function and size. loop_function: If not None, this function will be applied to i-th output in order to generate i+1-th input, and decoder_inputs will be ignored, except for the first element ("GO" symbol), see rnn_decoder for details. dtype: The dtype of the initial state of the rnn cell (default: tf.float32). scope: VariableScope for the created subgraph; default: "tied_rnn_seq2seq". Returns: A tuple of the form (outputs, state), where: outputs: A list of the same length as decoder_inputs of 2D Tensors with shape [batch_size x output_size] containing the generated outputs. state: The state of each decoder cell in each time-step. This is a list with length len(decoder_inputs) -- one item for each time-step. It is a 2D Tensor of shape [batch_size x cell.state_size]. """ with variable_scope.variable_scope("combined_tied_rnn_seq2seq"): scope = scope or "tied_rnn_seq2seq" _, enc_state = rnn.rnn( cell, encoder_inputs, dtype=dtype, scope=scope) variable_scope.get_variable_scope().reuse_variables() return rnn_decoder(decoder_inputs, enc_state, cell, loop_function=loop_function, scope=scope)
def _get_rnn_cell(cell_type, num_units, num_layers): """Constructs and return an `RNNCell`. Args: cell_type: either a string identifying the `RNNCell` type, or a subclass of `RNNCell`. num_units: the number of units in the `RNNCell`. num_layers: the number of layers in the RNN. Returns: An initialized `RNNCell`. Raises: ValueError: `cell_type` is an invalid `RNNCell` name. TypeError: `cell_type` is not a string or a subclass of `RNNCell`. """ if isinstance(cell_type, str): cell_type = _CELL_TYPES.get(cell_type) if cell_type is None: raise ValueError('The supported cell types are {}; got {}'.format( list(_CELL_TYPES.keys()), cell_type)) if not issubclass(cell_type, rnn_cell.RNNCell): raise TypeError( 'cell_type must be a subclass of RNNCell or one of {}.'.format( list(_CELL_TYPES.keys()))) cell = cell_type(num_units=num_units) if num_layers > 1: cell = rnn_cell.MultiRNNCell( [cell] * num_layers, state_is_tuple=True) return cell
def multi_value_rnn_regressor(num_units, cell_type='basic_rnn', cell_dtype=dtypes.float32, num_rnn_layers=1, optimizer_type='SGD', learning_rate=0.1, momentum=None, gradient_clipping_norm=10.0, model_dir=None, config=None): """Creates a RNN `Estimator` that predicts sequences of values. Args: num_units: the size of the RNN cells. cell_type: subclass of `RNNCell` or one of 'basic_rnn,' 'lstm' or 'gru'. cell_dtype: the dtype of the state and output for the given `cell_type`. num_rnn_layers: number of RNN layers. optimizer_type: the type of optimizer to use. Either a subclass of `Optimizer` or a string. learning_rate: learning rate. momentum: momentum value. Only used if `optimizer_type` is 'Momentum'. gradient_clipping_norm: parameter used for gradient clipping. If `None`, then no clipping is performed. model_dir: directory to use for The directory in which to save and restore the model graph, parameters, etc. config: A `RunConfig` instance. Returns: An initialized instance of `_MultiValueRNNEstimator`. """ optimizer = _get_optimizer(optimizer_type, learning_rate, momentum) cell = _get_rnn_cell(cell_type, num_units, num_rnn_layers) target_column = layers.regression_target() return _MultiValueRNNEstimator(cell, target_column, optimizer, model_dir, config, gradient_clipping_norm, dtype=cell_dtype)
def multi_value_rnn_classifier(num_classes, num_units, cell_type='basic_rnn', cell_dtype=dtypes.float32, num_rnn_layers=1, optimizer_type='SGD', learning_rate=0.1, momentum=None, gradient_clipping_norm=10.0, model_dir=None, config=None): """Creates a RNN `Estimator` that predicts sequences of labels. Args: num_classes: the number of classes for categorization. num_units: the size of the RNN cells. cell_type: subclass of `RNNCell` or one of 'basic_rnn,' 'lstm' or 'gru'. cell_dtype: the dtype of the state and output for the given `cell_type`. num_rnn_layers: number of RNN layers. optimizer_type: the type of optimizer to use. Either a subclass of `Optimizer` or a string. learning_rate: learning rate. momentum: momentum value. Only used if `optimizer_type` is 'Momentum'. gradient_clipping_norm: parameter used for gradient clipping. If `None`, then no clipping is performed. model_dir: directory to use for The directory in which to save and restore the model graph, parameters, etc. config: A `RunConfig` instance. Returns: An initialized instance of `_MultiValueRNNEstimator`. """ optimizer = _get_optimizer(optimizer_type, learning_rate, momentum) cell = _get_rnn_cell(cell_type, num_units, num_rnn_layers) target_column = layers.multi_class_target(n_classes=num_classes) return _MultiValueRNNEstimator(cell, target_column, optimizer, model_dir, config, gradient_clipping_norm, dtype=cell_dtype)
def single_value_rnn_regressor(num_units, cell_type='basic_rnn', cell_dtype=dtypes.float32, num_rnn_layers=1, optimizer_type='SGD', learning_rate=0.1, momentum=None, gradient_clipping_norm=10.0, model_dir=None, config=None): """Create a RNN `Estimator` that predicts single values. Args: num_units: the size of the RNN cells. cell_type: subclass of `RNNCell` or one of 'basic_rnn,' 'lstm' or 'gru'. cell_dtype: the dtype of the state and output for the given `cell_type`. num_rnn_layers: number of RNN layers. optimizer_type: the type of optimizer to use. Either a subclass of `Optimizer` or a string. learning_rate: learning rate. momentum: momentum value. Only used if `optimizer_type` is 'Momentum'. gradient_clipping_norm: parameter used for gradient clipping. If `None`, then no clipping is performed. model_dir: directory to use for The directory in which to save and restore the model graph, parameters, etc. config: A `RunConfig` instance. Returns: An initialized instance of `_MultiValueRNNEstimator`. """ optimizer = _get_optimizer(optimizer_type, learning_rate, momentum) cell = _get_rnn_cell(cell_type, num_units, num_rnn_layers) target_column = layers.regression_target() return _SingleValueRNNEstimator(cell, target_column, optimizer, model_dir, config, gradient_clipping_norm, dtype=cell_dtype)
def _to_rnn_cell(cell_or_type, num_units, num_layers): """Constructs and return an `RNNCell`. Args: cell_or_type: Either a string identifying the `RNNCell` type, a subclass of `RNNCell` or an instance of an `RNNCell`. num_units: The number of units in the `RNNCell`. num_layers: The number of layers in the RNN. Returns: An initialized `RNNCell`. Raises: ValueError: `cell_or_type` is an invalid `RNNCell` name. TypeError: `cell_or_type` is not a string or a subclass of `RNNCell`. """ if isinstance(cell_or_type, rnn_cell.RNNCell): return cell_or_type if isinstance(cell_or_type, str): cell_or_type = _CELL_TYPES.get(cell_or_type) if cell_or_type is None: raise ValueError('The supported cell types are {}; got {}'.format( list(_CELL_TYPES.keys()), cell_or_type)) if not issubclass(cell_or_type, rnn_cell.RNNCell): raise TypeError( 'cell_or_type must be a subclass of RNNCell or one of {}.'.format( list(_CELL_TYPES.keys()))) cell = cell_or_type(num_units=num_units) if num_layers > 1: cell = rnn_cell.MultiRNNCell( [cell] * num_layers, state_is_tuple=True) return cell
def rnn_decoder(decoder_inputs, initial_state, cell, loop_function=None, scope=None): """RNN decoder for the sequence-to-sequence model. Args: decoder_inputs: A list of 2D Tensors [batch_size x input_size]. initial_state: 2D Tensor with shape [batch_size x cell.state_size]. cell: rnn_cell.RNNCell defining the cell function and size. loop_function: If not None, this function will be applied to the i-th output in order to generate the i+1-st input, and decoder_inputs will be ignored, except for the first element ("GO" symbol). This can be used for decoding, but also for training to emulate http://arxiv.org/abs/1506.03099. Signature -- loop_function(prev, i) = next * prev is a 2D Tensor of shape [batch_size x output_size], * i is an integer, the step number (when advanced control is needed), * next is a 2D Tensor of shape [batch_size x input_size]. scope: VariableScope for the created subgraph; defaults to "rnn_decoder". Returns: A tuple of the form (outputs, state), where: outputs: A list of the same length as decoder_inputs of 2D Tensors with shape [batch_size x output_size] containing generated outputs. state: The state of each cell at the final time-step. It is a 2D Tensor of shape [batch_size x cell.state_size]. (Note that in some cases, like basic RNN cell or GRU cell, outputs and states can be the same. They are different for LSTM cells though.) """ with variable_scope.variable_scope(scope or "rnn_decoder"): state = initial_state outputs = [] prev = None for i, inp in enumerate(decoder_inputs): if loop_function is not None and prev is not None: with variable_scope.variable_scope("loop_function", reuse=True): inp = loop_function(prev, i) if i > 0: variable_scope.get_variable_scope().reuse_variables() output, state = cell(inp, state) outputs.append(output) if loop_function is not None: prev = output return outputs, state
def __init__(self, cell, target_column, optimizer, model_dir=None, config=None, gradient_clipping_norm=None, inputs_key='inputs', sequence_length_key='sequence_length', initial_state_key='initial_state', dtype=None, parallel_iterations=None, swap_memory=False, name=None): """Initialize `DynamicRNNEstimator`. Args: cell: an initialized `RNNCell` to be used in the RNN. target_column: an initialized `TargetColumn`, used to calculate loss and metrics. optimizer: an initialized `tensorflow.Optimizer`. model_dir: The directory in which to save and restore the model graph, parameters, etc. config: A `RunConfig` instance. gradient_clipping_norm: parameter used for gradient clipping. If `None`, then no clipping is performed. inputs_key: the key for input values in the features dict passed to `fit()`. sequence_length_key: the key for the sequence length tensor in the features dict passed to `fit()`. initial_state_key: the key for input values in the features dict passed to `fit()`. dtype: Parameter passed ot `dynamic_rnn`. The dtype of the state and output returned by `RNNCell`. parallel_iterations: Parameter passed ot `dynamic_rnn`. The number of iterations to run in parallel. swap_memory: Parameter passed ot `dynamic_rnn`. Transparently swap the tensors produced in forward inference but needed for back prop from GPU to CPU. name: Optional name for the `Estimator`. """ super(_DynamicRNNEstimator, self).__init__( model_dir=model_dir, config=config) self._cell = cell self._target_column = target_column self._optimizer = optimizer self._gradient_clipping_norm = gradient_clipping_norm self._inputs_key = inputs_key self._sequence_length_key = sequence_length_key self._initial_state_key = initial_state_key self._dtype = dtype or dtypes.float32 self._parallel_iterations = parallel_iterations self._swap_memory = swap_memory self._name = name or 'DynamicRnnEstimator'
def __init__(self, num_units, num_dims=1, input_dims=None, output_dims=None, priority_dims=None, non_recurrent_dims=None, tied=False, cell_fn=None, non_recurrent_fn=None): """Initialize the parameters of a Grid RNN cell Args: num_units: int, The number of units in all dimensions of this GridRNN cell num_dims: int, Number of dimensions of this grid. input_dims: int or list, List of dimensions which will receive input data. output_dims: int or list, List of dimensions from which the output will be recorded. priority_dims: int or list, List of dimensions to be considered as priority dimensions. If None, no dimension is prioritized. non_recurrent_dims: int or list, List of dimensions that are not recurrent. The transfer function for non-recurrent dimensions is specified via `non_recurrent_fn`, which is default to be `tensorflow.nn.relu`. tied: bool, Whether to share the weights among the dimensions of this GridRNN cell. If there are non-recurrent dimensions in the grid, weights are shared between each group of recurrent and non-recurrent dimensions. cell_fn: function, a function which returns the recurrent cell object. Has to be in the following signature: def cell_func(num_units, input_size): # ... and returns an object of type `RNNCell`. If None, LSTMCell with default parameters will be used. non_recurrent_fn: a tensorflow Op that will be the transfer function of the non-recurrent dimensions """ if num_dims < 1: raise ValueError('dims must be >= 1: {}'.format(num_dims)) self._config = _parse_rnn_config(num_dims, input_dims, output_dims, priority_dims, non_recurrent_dims, non_recurrent_fn or nn.relu, tied, num_units) cell_input_size = (self._config.num_dims - 1) * num_units if cell_fn is None: self._cell = rnn_cell.LSTMCell( num_units=num_units, input_size=cell_input_size, state_is_tuple=False) else: self._cell = cell_fn(num_units, cell_input_size) if not isinstance(self._cell, rnn_cell.RNNCell): raise ValueError('cell_fn must return an object of type RNNCell')
def __init__(self, cell, attn_length, attn_size=None, attn_vec_size=None, input_size=None, state_is_tuple=False): """Create a cell with attention. Args: cell: an RNNCell, an attention is added to it. attn_length: integer, the size of an attention window. attn_size: integer, the size of an attention vector. Equal to cell.output_size by default. attn_vec_size: integer, the number of convolutional features calculated on attention state and a size of the hidden layer built from base cell state. Equal attn_size to by default. input_size: integer, the size of a hidden linear layer, built from inputs and attention. Derived from the input tensor by default. state_is_tuple: If True, accepted and returned states are n-tuples, where `n = len(cells)`. By default (False), the states are all concatenated along the column axis. Raises: TypeError: if cell is not an RNNCell. ValueError: if cell returns a state tuple but the flag `state_is_tuple` is `False` or if attn_length is zero or less. """ if not isinstance(cell, rnn_cell.RNNCell): raise TypeError("The parameter cell is not RNNCell.") if nest.is_sequence(cell.state_size) and not state_is_tuple: raise ValueError("Cell returns tuple of states, but the flag " "state_is_tuple is not set. State size is: %s" % str(cell.state_size)) if attn_length <= 0: raise ValueError("attn_length should be greater than zero, got %s" % str(attn_length)) if not state_is_tuple: logging.warn( "%s: Using a concatenated state is slower and will soon be " "deprecated. Use state_is_tuple=True." % self) if attn_size is None: attn_size = cell.output_size if attn_vec_size is None: attn_vec_size = attn_size self._state_is_tuple = state_is_tuple self._cell = cell self._attn_vec_size = attn_vec_size self._input_size = input_size self._attn_size = attn_size self._attn_length = attn_length
def construct_rnn(initial_state, sequence_input, cell, num_label_columns, dtype=dtypes.float32, parallel_iterations=32, swap_memory=False): """Build an RNN and apply a fully connected layer to get the desired output. Args: initial_state: The initial state to pass the the RNN. If `None`, the default starting state for `self._cell` is used. sequence_input: A `Tensor` with shape `[batch_size, padded_length, d]` that will be passed as input to the RNN. cell: An initialized `RNNCell`. num_label_columns: The desired output dimension. dtype: dtype of `cell`. parallel_iterations: Number of iterations to run in parallel. Values >> 1 use more memory but take less time, while smaller values use less memory but computations take longer. swap_memory: Transparently swap the tensors produced in forward inference but needed for back prop from GPU to CPU. This allows training RNNs which would typically not fit on a single GPU, with very minimal (or no) performance penalty. Returns: activations: The output of the RNN, projected to `num_label_columns` dimensions. final_state: The final state output by the RNN. """ with ops.name_scope('RNN'): rnn_outputs, final_state = rnn.dynamic_rnn( cell=cell, inputs=sequence_input, initial_state=initial_state, dtype=dtype, parallel_iterations=parallel_iterations, swap_memory=swap_memory, time_major=False) activations = layers.fully_connected( inputs=rnn_outputs, num_outputs=num_label_columns, activation_fn=None, trainable=True) return activations, final_state
def embedding_rnn_decoder(decoder_inputs, initial_state, cell, num_symbols, embedding_size, output_projection=None, feed_previous=False, update_embedding_for_previous=True, scope=None): """RNN decoder with embedding and a pure-decoding option. Args: decoder_inputs: A list of 1D batch-sized int32 Tensors (decoder inputs). initial_state: 2D Tensor [batch_size x cell.state_size]. cell: rnn_cell.RNNCell defining the cell function. num_symbols: Integer, how many symbols come into the embedding. embedding_size: Integer, the length of the embedding vector for each symbol. output_projection: None or a pair (W, B) of output projection weights and biases; W has shape [output_size x num_symbols] and B has shape [num_symbols]; if provided and feed_previous=True, each fed previous output will first be multiplied by W and added B. feed_previous: Boolean; if True, only the first of decoder_inputs will be used (the "GO" symbol), and all other decoder inputs will be generated by: next = embedding_lookup(embedding, argmax(previous_output)), In effect, this implements a greedy decoder. It can also be used during training to emulate http://arxiv.org/abs/1506.03099. If False, decoder_inputs are used as given (the standard decoder case). update_embedding_for_previous: Boolean; if False and feed_previous=True, only the embedding for the first symbol of decoder_inputs (the "GO" symbol) will be updated by back propagation. Embeddings for the symbols generated from the decoder itself remain unchanged. This parameter has no effect if feed_previous=False. scope: VariableScope for the created subgraph; defaults to "embedding_rnn_decoder". Returns: A tuple of the form (outputs, state), where: outputs: A list of the same length as decoder_inputs of 2D Tensors with shape [batch_size x output_size] containing the generated outputs. state: The state of each decoder cell in each time-step. This is a list with length len(decoder_inputs) -- one item for each time-step. It is a 2D Tensor of shape [batch_size x cell.state_size]. Raises: ValueError: When output_projection has the wrong shape. """ if output_projection is not None: proj_weights = ops.convert_to_tensor(output_projection[0], dtype=dtypes.float32) proj_weights.get_shape().assert_is_compatible_with([None, num_symbols]) proj_biases = ops.convert_to_tensor( output_projection[1], dtype=dtypes.float32) proj_biases.get_shape().assert_is_compatible_with([num_symbols]) with variable_scope.variable_scope(scope or "embedding_rnn_decoder"): embedding = variable_scope.get_variable("embedding", [num_symbols, embedding_size]) loop_function = _extract_argmax_and_embed( embedding, output_projection, update_embedding_for_previous) if feed_previous else None emb_inp = ( embedding_ops.embedding_lookup(embedding, i) for i in decoder_inputs) return rnn_decoder(emb_inp, initial_state, cell, loop_function=loop_function)
