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

O modelo Sequencial

Ver em TensorFlow.org Executar no Google Colab Ver fonte no GitHub Download do caderno

Configuração

 import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
 

Quando usar um modelo Sequencial

Um modelo Sequential é apropriado para uma pilha simples de camadas em que cada camada possui exatamente um tensor de entrada e um tensor de saída .

Esquematicamente, o seguinte modelo Sequential :

 # Define Sequential model with 3 layers
model = keras.Sequential(
    [
        layers.Dense(2, activation="relu", name="layer1"),
        layers.Dense(3, activation="relu", name="layer2"),
        layers.Dense(4, name="layer3"),
    ]
)
# Call model on a test input
x = tf.ones((3, 3))
y = model(x)
 

é equivalente a esta função:

 # Create 3 layers
layer1 = layers.Dense(2, activation="relu", name="layer1")
layer2 = layers.Dense(3, activation="relu", name="layer2")
layer3 = layers.Dense(4, name="layer3")

# Call layers on a test input
x = tf.ones((3, 3))
y = layer3(layer2(layer1(x)))
 

Um modelo seqüencial não é apropriado quando:

  • Seu modelo possui várias entradas ou várias saídas
  • Qualquer uma das suas camadas possui várias entradas ou saídas
  • Você precisa fazer o compartilhamento de camadas
  • Você deseja topologia não linear (por exemplo, uma conexão residual, um modelo de várias ramificações)

Criando um modelo seqüencial

Você pode criar um modelo sequencial passando uma lista de camadas para o construtor Sequential:

 model = keras.Sequential(
    [
        layers.Dense(2, activation="relu"),
        layers.Dense(3, activation="relu"),
        layers.Dense(4),
    ]
)
 

Suas camadas são acessíveis através do atributo de layers :

 model.layers
 
[<tensorflow.python.keras.layers.core.Dense at 0x7f37ffe66668>,
 <tensorflow.python.keras.layers.core.Dense at 0x7f37f553fc50>,
 <tensorflow.python.keras.layers.core.Dense at 0x7f37680de2b0>]

Você também pode criar um modelo sequencial incrementalmente através do método add() :

 model = keras.Sequential()
model.add(layers.Dense(2, activation="relu"))
model.add(layers.Dense(3, activation="relu"))
model.add(layers.Dense(4))
 

Observe que também há um método pop() correspondente para remover camadas: um modelo seqüencial se comporta muito como uma lista de camadas.

 model.pop()
print(len(model.layers))  # 2
 
2

Observe também que o construtor Sequential aceita um argumento de name , como qualquer camada ou modelo no Keras. Isso é útil para anotar gráficos do TensorBoard com nomes semanticamente significativos.

 model = keras.Sequential(name="my_sequential")
model.add(layers.Dense(2, activation="relu", name="layer1"))
model.add(layers.Dense(3, activation="relu", name="layer2"))
model.add(layers.Dense(4, name="layer3"))
 

Especificando a forma da entrada antecipadamente

Geralmente, todas as camadas do Keras precisam conhecer o formato de suas entradas para poder criar seus pesos. Portanto, quando você cria uma camada como esta, inicialmente, ela não tem pesos:

 layer = layers.Dense(3)
layer.weights  # Empty
 
[]

Ele cria seus pesos na primeira vez em que é chamado em uma entrada, pois o formato dos pesos depende do formato das entradas:

 # Call layer on a test input
x = tf.ones((1, 4))
y = layer(x)
layer.weights  # Now it has weights, of shape (4, 3) and (3,)
 
[<tf.Variable 'dense_6/kernel:0' shape=(4, 3) dtype=float32, numpy=
 array([[-0.8131663 , -0.49988765, -0.02397203],
        [-0.3190418 ,  0.01101786,  0.85226357],
        [-0.602435  , -0.10381919,  0.63280225],
        [-0.3388477 ,  0.11859643, -0.10677373]], dtype=float32)>,
 <tf.Variable 'dense_6/bias:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]

Naturalmente, isso também se aplica aos modelos seqüenciais. Quando você instancia um modelo Sequencial sem um formato de entrada, ele não é "construído": não possui pesos (e chamar model.weights resulta em um erro informando exatamente isso). Os pesos são criados quando o modelo vê pela primeira vez alguns dados de entrada:

 model = keras.Sequential(
    [
        layers.Dense(2, activation="relu"),
        layers.Dense(3, activation="relu"),
        layers.Dense(4),
    ]
)  # No weights at this stage!

# At this point, you can't do this:
# model.weights

# You also can't do this:
# model.summary()

# Call the model on a test input
x = tf.ones((1, 4))
y = model(x)
print("Number of weights after calling the model:", len(model.weights))  # 6
 
Number of weights after calling the model: 6

Depois que um modelo é "construído", você pode chamar seu método summary() para exibir seu conteúdo:

 model.summary()
 
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_7 (Dense)              multiple                  10        
_________________________________________________________________
dense_8 (Dense)              multiple                  9         
_________________________________________________________________
dense_9 (Dense)              multiple                  16        
=================================================================
Total params: 35
Trainable params: 35
Non-trainable params: 0
_________________________________________________________________

No entanto, pode ser muito útil ao criar um modelo sequencial de forma incremental para poder exibir o resumo do modelo até o momento, incluindo a forma de saída atual. Nesse caso, você deve iniciar seu modelo passando um objeto Input para seu modelo, para que ele conheça sua forma de entrada desde o início:

 model = keras.Sequential()
model.add(keras.Input(shape=(4,)))
model.add(layers.Dense(2, activation="relu"))

model.summary()
 
Model: "sequential_4"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_10 (Dense)             (None, 2)                 10        
=================================================================
Total params: 10
Trainable params: 10
Non-trainable params: 0
_________________________________________________________________

Observe que o objeto Input não é exibido como parte do model.layers , pois não é uma camada:

 model.layers
 
[<tensorflow.python.keras.layers.core.Dense at 0x7f37680deb00>]

Uma alternativa simples é apenas passar um argumento input_shape para sua primeira camada:

 model = keras.Sequential()
model.add(layers.Dense(2, activation="relu", input_shape=(4,)))

model.summary()
 
Model: "sequential_5"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_11 (Dense)             (None, 2)                 10        
=================================================================
Total params: 10
Trainable params: 10
Non-trainable params: 0
_________________________________________________________________

Os modelos criados com uma forma de entrada predefinida como essa sempre têm pesos (mesmo antes de ver quaisquer dados) e sempre têm uma forma de saída definida.

Em geral, é uma prática recomendada para sempre especificar sempre a forma de entrada de um modelo Sequencial, se você souber o que é.

Um fluxo de trabalho de depuração comum: add() + summary()

Ao criar uma nova arquitetura sequencial, é útil empilhar camadas de forma incremental com add() e imprimir resumos de modelo com frequência. Por exemplo, isto permite-lhe controlar a forma como uma pilha de Conv2D e MaxPooling2D camadas é downsampling mapas de características imagem:

 model = keras.Sequential()
model.add(keras.Input(shape=(250, 250, 3)))  # 250x250 RGB images
model.add(layers.Conv2D(32, 5, strides=2, activation="relu"))
model.add(layers.Conv2D(32, 3, activation="relu"))
model.add(layers.MaxPooling2D(3))

# Can you guess what the current output shape is at this point? Probably not.
# Let's just print it:
model.summary()

# The answer was: (40, 40, 32), so we can keep downsampling...

model.add(layers.Conv2D(32, 3, activation="relu"))
model.add(layers.Conv2D(32, 3, activation="relu"))
model.add(layers.MaxPooling2D(3))
model.add(layers.Conv2D(32, 3, activation="relu"))
model.add(layers.Conv2D(32, 3, activation="relu"))
model.add(layers.MaxPooling2D(2))

# And now?
model.summary()

# Now that we have 4x4 feature maps, time to apply global max pooling.
model.add(layers.GlobalMaxPooling2D())

# Finally, we add a classification layer.
model.add(layers.Dense(10))
 
Model: "sequential_6"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 123, 123, 32)      2432      
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 121, 121, 32)      9248      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 40, 40, 32)        0         
=================================================================
Total params: 11,680
Trainable params: 11,680
Non-trainable params: 0
_________________________________________________________________
Model: "sequential_6"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 123, 123, 32)      2432      
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 121, 121, 32)      9248      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 40, 40, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 38, 38, 32)        9248      
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 36, 36, 32)        9248      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 12, 12, 32)        0         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 10, 10, 32)        9248      
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 8, 8, 32)          9248      
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 4, 4, 32)          0         
=================================================================
Total params: 48,672
Trainable params: 48,672
Non-trainable params: 0
_________________________________________________________________

Muito prático, né?

O que fazer depois de ter um modelo

Quando a arquitetura do modelo estiver pronta, você desejará:

Extração de recursos com um modelo Sequencial

Depois que um modelo Sequencial é construído, ele se comporta como um modelo de API Funcional . Isso significa que cada camada tem um atributo de input e output . Esses atributos podem ser usados ​​para fazer coisas legais, como criar rapidamente um modelo que extrai as saídas de todas as camadas intermediárias em um modelo Sequencial:

 initial_model = keras.Sequential(
    [
        keras.Input(shape=(250, 250, 3)),
        layers.Conv2D(32, 5, strides=2, activation="relu"),
        layers.Conv2D(32, 3, activation="relu"),
        layers.Conv2D(32, 3, activation="relu"),
    ]
)
feature_extractor = keras.Model(
    inputs=initial_model.inputs,
    outputs=[layer.output for layer in initial_model.layers],
)

# Call feature extractor on test input.
x = tf.ones((1, 250, 250, 3))
features = feature_extractor(x)
 

Aqui está um exemplo semelhante que apenas extrai recursos de uma camada:

 initial_model = keras.Sequential(
    [
        keras.Input(shape=(250, 250, 3)),
        layers.Conv2D(32, 5, strides=2, activation="relu"),
        layers.Conv2D(32, 3, activation="relu", name="my_intermediate_layer"),
        layers.Conv2D(32, 3, activation="relu"),
    ]
)
feature_extractor = keras.Model(
    inputs=initial_model.inputs,
    outputs=initial_model.get_layer(name="my_intermediate_layer").output,
)
# Call feature extractor on test input.
x = tf.ones((1, 250, 250, 3))
features = feature_extractor(x)
 

Transferir aprendizado com um modelo Sequencial

O aprendizado de transferência consiste em congelar as camadas inferiores em um modelo e treinar apenas as camadas superiores. Se você não estiver familiarizado com isso, leia nosso guia para transferir aprendizado .

Aqui estão dois modelos comuns de aprendizado de transferência envolvendo modelos sequenciais.

Primeiro, digamos que você tenha um modelo Sequencial e deseja congelar todas as camadas, exceto a última. Nesse caso, você simplesmente itera sobre model.layers e define layer.trainable = False em cada camada, exceto a última. Como isso:

 model = keras.Sequential([
    keras.Input(shape=(784))
    layers.Dense(32, activation='relu'),
    layers.Dense(32, activation='relu'),
    layers.Dense(32, activation='relu'),
    layers.Dense(10),
])

# Presumably you would want to first load pre-trained weights.
model.load_weights(...)

# Freeze all layers except the last one.
for layer in model.layers[:-1]:
  layer.trainable = False

# Recompile and train (this will only update the weights of the last layer).
model.compile(...)
model.fit(...)
 

Outro modelo comum é usar um modelo Sequencial para empilhar um modelo pré-treinado e algumas camadas de classificação recém-inicializadas. Como isso:

 # Load a convolutional base with pre-trained weights
base_model = keras.applications.Xception(
    weights='imagenet',
    include_top=False,
    pooling='avg')

# Freeze the base model
base_model.trainable = False

# Use a Sequential model to add a trainable classifier on top
model = keras.Sequential([
    base_model,
    layers.Dense(1000),
])

# Compile & train
model.compile(...)
model.fit(...)
 

Se você transferir o aprendizado, provavelmente se encontrará freqüentemente usando esses dois padrões.

É tudo o que você precisa saber sobre modelos sequenciais!

Para saber mais sobre a construção de modelos no Keras, consulte: