parameters: (self, current_times, current_values, state, predictions)
return_statement: return (new_state_tuple, predictions)
docstring: Update model state based on observations.
      Note that we don't do much here aside from computing a loss. In this case
      it's easier to update the RNN state in _prediction_step, since that covers
      running the RNN both on observations (from this method) and our own
      predictions. This distinction can be important for probabilistic models,
      where repeatedly predicting without filtering should lead to low-confidence
      predictions.
      Args:
        current_times: A [batch size] integer Tensor.
        current_values: A [batch size, self.num_features] floating point Tensor
          with new observations.
        state: The model's state tuple.
        predictions: The output of the previous `_prediction_step`.
      Returns:
        A tuple of new state and a predictions dictionary updated to include a
        loss (note that we could also return other measures of goodness of fit,
        although only "loss" will be optimized).
docstring_summary: Update model state based on observations.
      Note that we don't do much here aside from computing a loss. In this case
      it's easier to update the RNN state in _prediction_step, since that covers
      running the RNN both on observations (from this method) and our own
      predictions. This distinction can be important for probabilistic models,
      where repeatedly predicting without filtering should lead to low-confidence
      predictions.
      Args:
        current_times: A [batch size] integer Tensor.
        current_values: A [batch size, self.num_features] floating point Tensor
          with new observations.
        state: The model's state tuple.
        predictions: The output of the previous `_prediction_step`.
      Returns:
        A tuple of new state and a predictions dictionary updated to include a
        loss (note that we could also return other measures of goodness of fit,
        although only "loss" will be optimized).
docstring_tokens: Update model state based on observations . Note that we don t do much here aside from computing a loss . In this case it s easier to update the RNN state in _prediction_step since that covers running the RNN both on observations ( from this method ) and our own predictions . This distinction can be important for probabilistic models where repeatedly predicting without filtering should lead to low - confidence predictions . Args : current_times : A [ batch size ] integer Tensor . current_values : A [ batch size self . num_features ] floating point Tensor with new observations . state : The model s state tuple . predictions : The output of the previous _prediction_step . Returns : A tuple of new state and a predictions dictionary updated to include a loss ( note that we could also return other measures of goodness of fit although only loss will be optimized ) .
function: def _filtering_step(self, current_times, current_values, state, predictions):
      """Update model state based on observations.
      Note that we don't do much here aside from computing a loss. In this case
      it's easier to update the RNN state in _prediction_step, since that covers
      running the RNN both on observations (from this method) and our own
      predictions. This distinction can be important for probabilistic models,
      where repeatedly predicting without filtering should lead to low-confidence
      predictions.
      Args:
        current_times: A [batch size] integer Tensor.
        current_values: A [batch size, self.num_features] floating point Tensor
          with new observations.
        state: The model's state tuple.
        predictions: The output of the previous `_prediction_step`.
      Returns:
        A tuple of new state and a predictions dictionary updated to include a
        loss (note that we could also return other measures of goodness of fit,
        although only "loss" will be optimized).
      """
      state_from_time, prediction, lstm_state = state
      with tf.control_dependencies(
              [tf.assert_equal(current_times, state_from_time)]):
        transformed_values = self._transform(current_values)
        # Use mean squared error across features for the loss.
        predictions["loss"] = tf.reduce_mean(
            (prediction - transformed_values) ** 2, axis=-1)
        # Keep track of the new observation in model state. It won't be run
        # through the LSTM until the next _imputation_step.
        new_state_tuple = (current_times, transformed_values, lstm_state)
      return (new_state_tuple, predictions)
function_tokens: def _filtering_step ( self , current_times , current_values , state , predictions ) : state_from_time , prediction , lstm_state = state with tf . control_dependencies ( [ tf . assert_equal ( current_times , state_from_time ) ] ) : transformed_values = self . _transform ( current_values ) # Use mean squared error across features for the loss. predictions [ "loss" ] = tf . reduce_mean ( ( prediction - transformed_values ) ** 2 , axis = - 1 ) # Keep track of the new observation in model state. It won't be run # through the LSTM until the next _imputation_step. new_state_tuple = ( current_times , transformed_values , lstm_state ) return ( new_state_tuple , predictions )