Esta página foi traduzida pela API Cloud Translation.
Switch to English

tf.keras.layers.RNN

TensorFlow 1 versão Ver fonte no GitHub

Classe base para camadas recorrentes.

Herda de: Layer

Usado nos cadernos

Usado na guia Usado nos tutoriais

Veja o guia API Keras RNN para obter detalhes sobre o uso de RNN API.

cell Um exemplo de células RNN ou uma lista de exemplos de células RNN. célula A RNN é uma classe que tem:

  • A call(input_at_t, states_at_t) método, retornando (output_at_t, states_at_t_plus_1) . A chamada de método da célula também pode tomar o argumento opcional constants , consulte a secção "Nota sobre passando constantes externos" abaixo.
  • A state_size atributo. Este pode ser um único número inteiro (estado único) no caso em que é o tamanho do estado recorrente. Isso também pode ser uma lista / tupla de inteiros (um tamanho por estado). O state_size também pode ser TensorShape ou tupla / lista de TensorShape, para representar estado dimensão elevada.
  • A output_size atributo. Este pode ser um único número inteiro ou uma TensorShape, que representam a forma da saída. Por razões de compatibilidade para trás, se esse atributo não está disponível para a célula, o valor será inferida pelo primeiro elemento da state_size .
  • Um get_initial_state(inputs=None, batch_size=None, dtype=None) método que cria um tensor destinado a ser alimentado para call() como o estado inicial, se o utilizador não especificou qualquer estado inicial através de outros meios. O estado inicial retornou deve ter uma forma de [batch_size, cell.state_size]. A célula pode optar por criar um tensor cheio de zeros, ou cheio de outros valores com base na implementação da célula. inputs é o tensor de entrada para a camada RNN, que deve conter o tamanho do lote, como a sua forma [0], e também DTYPE. Note-se que a forma [0] pode ser None durante a construção de gráfico. Ou as inputs ou a par de batch_size e dtype são fornecidos. batch_size é um tensor escalar que representa a dimensão do lote de entradas. dtype é tf.DType que representa o dtipo das entradas. Por razões de compatibilidade para trás, se este método não é implementado pela célula, a camada RNN vai criar um tensor preenchido zero com o tamanho de [batch_size, cell.state_size]. No caso em que cell é uma lista de exemplos de células RNN, as células irão ser empilhados em cima uns dos outros no RNN, resultando em um RNN empilhados eficiente.
return_sequences Boolean (default False ). Se para voltar a última saída na seqüência de saída, ou a sequência completa.
return_state Boolean (default False ). Se devolver o último estado, além da saída.
go_backwards Boolean (default False ). Se for verdade, processar a sequência de entrada para trás e para retornar a sequência inversa.
stateful Boolean (default False ). Se for verdade, o último estado para cada amostra no índice i, em um lote vai ser utilizado como o estado inicial para a amostra de índice i da seguinte lote.
unroll Boolean (default False ). Se for verdade, a rede será desenrolado, será usado então um laço simbólico. Desenrolar pode acelerar-se um RNN, embora tende a ser mais memória intensiva. Desenrolamento é adequado apenas para sequências curtas.
time_major O formato forma das inputs e outputs tensores. Se for verdade, as entradas e saídas vai estar em forma (timesteps, batch, ...) , enquanto que no caso False, será (batch, timesteps, ...) . Usando time_major = True é um pouco mais eficiente porque evita transpostas no início e no fim do cálculo RNN. No entanto, a maior parte dos dados é TensorFlow lote-principal, de modo que por esta função padrão aceita a entrada e emite saída em forma de lote-principal.
zero_output_for_mask Boolean (default False ). Se a saída deve usar zeros para os Timesteps mascarados. Note que este campo só é utilizado quando return_sequences é verdadeiro e máscara é fornecido. Pode útil se você quiser reutilizar a seqüência de saída crua da RNN, sem interferência das Timesteps mascarados, por exemplo, a fusão RNNs bidirecionais.

argumentos de chamada:

  • inputs : tensor de entrada.
  • mask : tensor binário de forma [batch_size, timesteps] indica se um determinado instante temporal deve ser mascarado.
  • training : Python booleano que indica se a camada deve se comportar no modo de treino ou no modo de inferência. Este argumento é passado para o celular quando chamá-lo. Isto é para uso com células que usam abandono.
  • initial_state : Lista de tensores estado inicial a ser passado para a primeira chamada do celular.
  • constants : Lista de tensores constantes a serem passados para a célula em cada iteração.

forma de entrada:

Tensor ND com forma [batch_size, timesteps, ...] ou [timesteps, batch_size, ...] quando time_major é True.

forma de saída:

  • Se return_state : uma lista de tensores. O primeiro é o tensor de saída. Os tensores restantes são os últimos estados, cada um com a forma [batch_size, state_size] , onde state_size poderia ser uma forma tensor de alta dimensão.
  • Se return_sequences : ND tensor com forma [batch_size, timesteps, output_size] , onde output_size poderia ser uma forma de alta dimensão tensor, ou [timesteps, batch_size, output_size] quando time_major é verdadeiro.
  • Logo, ND tensor com forma [batch_size, output_size] , onde output_size poderia ser uma forma tensor de alta dimensão.

mascaramento:

Esta camada de suporte de máscara para os dados de entrada com um número variável de Timesteps. Para introduzir máscaras para os seus dados, use uma camada [tf.keras.layers.Embedding] com o mask_zero conjunto de parâmetros para True .

Nota sobre o uso statefulness em RNNs: Você pode definir camadas RNN para ser 'stateful', o que significa que os estados computados para as amostras em um lote serão reutilizados como estados iniciais para as amostras no próximo lote. Isto assume um mapeamento um-para-um entre as amostras em diferentes lotes sucessivos.

Para habilitar statefulness:

 - Specify `stateful=True` in the layer constructor.
- Specify a fixed batch size for your model, by passing
  If sequential model:
    `batch_input_shape=(...)` to the first layer in your model.
  Else for functional model with 1 or more Input layers:
    `batch_shape=(...)` to all the first layers in your model.
  This is the expected shape of your inputs
  *including the batch size*.
  It should be a tuple of integers, e.g. `(32, 10, 100)`.
- Specify `shuffle=False` when calling fit().
 

Para repor os estados de seu modelo, chamada .reset_states() em qualquer uma camada específica, ou em todo o seu modelo.

Nota sobre como especificar o estado inicial do RNNs: Você pode especificar o estado inicial de camadas RNN simbolicamente, chamando-os com a palavra chave argumento initial_state . O valor de initial_state deve ser um tensor ou lista dos tensores que representam o estado inicial da camada RNN.

Você pode especificar o estado inicial de camadas RNN numericamente chamando reset_states com o argumento de palavra-chave states . O valor de states deve ser uma matriz numpy ou lista de matrizes numpy que representam o estado inicial da camada RNN.

Nota sobre passando constantes externos para RNNs: Você pode passar constantes "externos" para a célula usando as constants chave argumento de RNN. call (bem como RNN.call ) método. Isto requer que o cell.call método aceita o mesmo argumento de palavra-chave constants . Tais constantes podem ser usados ​​para condicionar a transformação de células em entradas estáticos adicionais (não mudar ao longo do tempo), também conhecido como um mecanismo de atenção.

Exemplos:

 # First, let's define a RNN Cell, as a layer subclass.

class MinimalRNNCell(keras.layers.Layer):

    def __init__(self, units, **kwargs):
        self.units = units
        self.state_size = units
        super(MinimalRNNCell, self).__init__(**kwargs)

    def build(self, input_shape):
        self.kernel = self.add_weight(shape=(input_shape[-1], self.units),
                                      initializer='uniform',
                                      name='kernel')
        self.recurrent_kernel = self.add_weight(
            shape=(self.units, self.units),
            initializer='uniform',
            name='recurrent_kernel')
        self.built = True

    def call(self, inputs, states):
        prev_output = states[0]
        h = K.dot(inputs, self.kernel)
        output = h + K.dot(prev_output, self.recurrent_kernel)
        return output, [output]

# Let's use this cell in a RNN layer:

cell = MinimalRNNCell(32)
x = keras.Input((None, 5))
layer = RNN(cell)
y = layer(x)

# Here's how to use the cell to build a stacked RNN:

cells = [MinimalRNNCell(32), MinimalRNNCell(64)]
x = keras.Input((None, 5))
layer = RNN(cells)
y = layer(x)
 

states

Métodos

reset_states

Ver fonte

Redefinir os estados registados para a camada RNN estado.

Só pode ser utilizado quando a camada de RNN é construído com stateful = True . Args: estados: matrizes Numpy que contém o valor para o estado inicial, que será alimentar a célula na primeira etapa de tempo. Quando o valor é Nenhum, matriz numpy preenchido zero será criado com base no tamanho do estado da célula.

Levanta
AttributeError Quando a camada não é RNN estado.
ValueError Quando o tamanho do lote da camada RNN é desconhecido.
ValueError Quando a matriz de entrada numpy não é compatível com o estado da camada RNN, ou tamanho ou sábio DTYPE sensato.