Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Model Sequential

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Mempersiapkan

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

Kapan harus menggunakan model Sequential

Model Sequential cocok untuk tumpukan lapisan yang polos di mana setiap lapisan memiliki satu tensor input dan satu tensor output .

Secara skematis, model Sequential berikut:

 # 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)
 

setara dengan fungsi ini:

 # 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)))
 

Model berurutan tidak sesuai ketika:

  • Model Anda memiliki banyak input atau banyak output
  • Setiap lapisan Anda memiliki banyak input atau banyak output
  • Anda perlu melakukan berbagi lapisan
  • Anda menginginkan topologi non-linear (mis. Koneksi residual, model multi-cabang)

Membuat model Sequential

Anda dapat membuat model Sequential dengan meneruskan daftar lapisan ke konstruktor Sequential:

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

Lapisannya dapat diakses melalui atribut 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>]

Anda juga dapat membuat model Sequential secara bertahap melalui metode add() :

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

Perhatikan bahwa ada juga metode pop() sesuai untuk menghapus lapisan: model Sequential berperilaku sangat mirip dengan daftar lapisan.

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

Perhatikan juga bahwa konstruktor Sequential menerima argumen name , seperti halnya layer atau model dalam Keras. Ini berguna untuk membubuhi keterangan grafik TensorBoard dengan nama yang bermakna secara semantik.

 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"))
 

Menentukan bentuk input terlebih dahulu

Secara umum, semua lapisan dalam Keras perlu mengetahui bentuk input mereka agar dapat membuat bobotnya. Jadi ketika Anda membuat layer seperti ini, awalnya, ia tidak memiliki bobot:

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

Ini menciptakan bobotnya saat pertama kali dipanggil pada input, karena bentuk bobot tergantung pada bentuk input:

 # 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)>]

Tentu, ini juga berlaku untuk model Sequential. Ketika Anda instantiate model Sequential tanpa bentuk input, itu bukan "dibangun": ia tidak memiliki bobot (dan memanggil model.weights menghasilkan kesalahan yang menyatakan hal ini). Bobot dibuat saat model pertama kali melihat beberapa data input:

 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

Setelah model "dibangun", Anda dapat memanggil metode summary() untuk menampilkan kontennya:

 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
_________________________________________________________________

Namun, ini bisa sangat berguna ketika membangun model Sequential secara bertahap untuk dapat menampilkan ringkasan model sejauh ini, termasuk bentuk output saat ini. Dalam hal ini, Anda harus memulai model Anda dengan mengirimkan objek Input ke model Anda, sehingga ia tahu bentuk inputnya dari awal:

 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
_________________________________________________________________

Perhatikan bahwa objek Input tidak ditampilkan sebagai bagian dari model.layers , karena itu bukan layer:

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

Alternatif sederhana adalah dengan hanya memberikan argumen input_shape ke lapisan pertama Anda:

 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
_________________________________________________________________

Model yang dibangun dengan bentuk input yang telah ditentukan seperti ini selalu memiliki bobot (bahkan sebelum melihat data apa pun) dan selalu memiliki bentuk output yang ditentukan.

Secara umum, ini merupakan praktik terbaik yang disarankan untuk selalu menentukan bentuk input dari model Sequential terlebih dahulu jika Anda tahu apa itu.

Alur kerja debugging yang umum: add() + summary()

Saat membangun arsitektur Sequential baru, akan berguna untuk menumpuk lapisan secara bertahap dengan add() dan sering mencetak ringkasan model. Sebagai contoh, ini memungkinkan Anda untuk memantau bagaimana setumpuk Conv2D dan MaxPooling2D lapisan yang downsampling peta fitur image:

 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
_________________________________________________________________

Sangat praktis, bukan?

Apa yang harus dilakukan setelah Anda memiliki model

Setelah arsitektur model Anda siap, Anda ingin:

Ekstraksi fitur dengan model Sequential

Setelah model Sequential dibangun, ia berperilaku seperti model API Fungsional . Ini berarti bahwa setiap lapisan memiliki atribut input dan output . Atribut ini dapat digunakan untuk melakukan hal-hal yang rapi, seperti dengan cepat membuat model yang mengekstrak output dari semua lapisan menengah dalam model Sequential:

 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)
 

Berikut adalah contoh serupa yang hanya mengekstrak fitur dari satu lapisan:

 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)
 

Mentransfer pembelajaran dengan model Sequential

Pembelajaran transfer terdiri dari membekukan lapisan bawah dalam model dan hanya melatih lapisan atas. Jika Anda tidak terbiasa dengan itu, pastikan untuk membaca panduan kami untuk mentransfer pembelajaran .

Berikut adalah dua cetak biru pembelajaran transfer umum yang melibatkan model Sequential.

Pertama, katakanlah Anda memiliki model Sequential, dan Anda ingin membekukan semua layer kecuali yang terakhir. Dalam hal ini, Anda hanya akan mengulangi model.layers dan mengatur layer.trainable = False pada setiap lapisan, kecuali yang terakhir. Seperti ini:

 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(...)
 

Cetak biru umum lainnya adalah dengan menggunakan model Sequential untuk menumpuk model pra-terlatih dan beberapa lapisan klasifikasi yang baru diinisialisasi. Seperti ini:

 # 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(...)
 

Jika Anda benar-benar belajar, Anda mungkin akan sering menggunakan kedua pola ini.

Hanya itu yang perlu Anda ketahui tentang model Sequential!

Untuk mengetahui lebih lanjut tentang membangun model di Keras, lihat: