इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

अनुक्रमिक मॉडल

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

सेट अप

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

अनुक्रमिक मॉडल का उपयोग कब करें

एक Sequential मॉडल परतों के एक सादे ढेर के लिए उपयुक्त है, जहां प्रत्येक परत में एक इनपुट टेंसर और एक आउटपुट टेंसर होता है

योजनाबद्ध रूप से, निम्नलिखित 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)

इस समारोह के बराबर है:

# 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 = keras.Sequential(
    [
        layers.Dense(2, activation="relu"),
        layers.Dense(3, activation="relu"),
        layers.Dense(4),
    ]
)

इसकी परतें layers विशेषता के माध्यम से सुलभ हैं:

model.layers
[<tensorflow.python.keras.layers.core.Dense at 0x7f7d1d5c7898>,
 <tensorflow.python.keras.layers.core.Dense at 0x7f7d2f6e0a20>,
 <tensorflow.python.keras.layers.core.Dense at 0x7f7d16beb9b0>]

आप add() विधि के माध्यम से एक अनुक्रमिक मॉडल भी बना सकते हैं:

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

ध्यान दें कि परतों को हटाने के लिए एक समान pop() विधि भी है: एक अनुक्रमिक मॉडल परतों की सूची की तरह बहुत व्यवहार करता है।

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

यह भी ध्यान दें कि अनुक्रमिक निर्माता एक name तर्क को स्वीकार करता है, जैसे कि केर में किसी भी परत या मॉडल। यह TensorBoard ग्राफ़ को शब्दार्थ अर्थपूर्ण नामों के साथ एनोटेट करने के लिए उपयोगी है।

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

इनपुट आकार को पहले से निर्दिष्ट करना

आमतौर पर, केरस में सभी परतों को अपने वजन को बनाने में सक्षम होने के लिए उनके इनपुट के आकार को जानने की आवश्यकता होती है। इसलिए जब आप इस तरह से एक परत बनाते हैं, तो शुरू में इसका कोई वज़न नहीं होता है:

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

यह पहली बार अपने वजन को बनाता है इसे इनपुट पर कहा जाता है, क्योंकि वजन का आकार इनपुट के आकार पर निर्भर करता है:

# 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.06262648,  0.36915624, -0.27826005],
        [-0.6703571 , -0.03467071,  0.80370367],
        [-0.00725174,  0.19120002,  0.34244013],
        [-0.20762473, -0.31104177, -0.26624495]], dtype=float32)>,
 <tf.Variable 'dense_6/bias:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]

स्वाभाविक रूप से, यह अनुक्रमिक मॉडल पर भी लागू होता है। जब आप एक इनपुट आकार के बिना एक अनुक्रमिक मॉडल को model.weights , तो यह "निर्मित नहीं" होता है: इसमें कोई वेट नहीं होता (और कॉलिंग model.weights परिणाम केवल यह बताते हुए त्रुटि होती है)। जब मॉडल पहली बार कुछ इनपुट डेटा देखता है तो वजन बनाया जाता है:

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

एक बार एक मॉडल "निर्मित" होने के बाद, आप इसकी सामग्री को प्रदर्शित करने के लिए इसका summary() विधि कह सकते हैं:

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

हालाँकि, यह तब बहुत उपयोगी हो सकता है जब एक सेक्शनल मॉडल को बढ़ाकर वर्तमान आउटपुट आकार सहित मॉडल का सारांश प्रदर्शित करने में सक्षम हो। इस स्थिति में, आपको अपने मॉडल पर एक Input ऑब्जेक्ट पास करके अपना मॉडल शुरू करना चाहिए, ताकि उसे शुरू से ही इसका इनपुट आकार पता हो:

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
_________________________________________________________________

ध्यान दें कि Input ऑब्जेक्ट को model.layers भाग के रूप में प्रदर्शित नहीं किया गया है, क्योंकि यह एक परत नहीं है:

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

एक सरल विकल्प यह है कि आप अपनी पहली लेयर में एक input_shape तर्क पास करें:

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
_________________________________________________________________

इस तरह एक पूर्वनिर्धारित इनपुट आकार के साथ बनाए गए मॉडल में हमेशा वजन होता है (किसी भी डेटा को देखने से पहले) और हमेशा एक परिभाषित आउटपुट आकार होता है।

सामान्य तौर पर, यह हमेशा एक अनुक्रमिक मॉडल के इनपुट आकार को पहले से निर्दिष्ट करने के लिए अनुशंसित सर्वोत्तम अभ्यास है यदि आप जानते हैं कि यह क्या है।

एक सामान्य डीबगिंग वर्कफ़्लो: add() + summary()

एक नया अनुक्रमिक वास्तुकला का निर्माण करते समय, यह add() और अक्सर प्रिंट मॉडल सारांश के साथ वृद्धिशील स्टैक परतों के लिए उपयोगी होता है। उदाहरण के लिए, यह आपको मॉनिटर करने में सक्षम बनाता है कि कैसे Conv2D और MaxPooling2D परतों का ढेर Conv2D छवि फीचर मानचित्रों के साथ है:

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
_________________________________________________________________

बहुत व्यावहारिक है, है ना?

एक बार आपके पास एक मॉडल होने के लिए क्या करें

एक बार जब आपका मॉडल आर्किटेक्चर तैयार हो जाएगा, तो आप चाहते हैं:

एक अनुक्रमिक मॉडल के साथ सुविधा निष्कर्षण

एक बार एक सेक्शनल मॉडल बनाया गया है, यह एक कार्यात्मक एपीआई मॉडल की तरह व्यवहार करता है। इसका मतलब है कि हर परत में एक input और output विशेषता है। इन विशेषताओं का उपयोग साफ-सुथरा काम करने के लिए किया जा सकता है, जैसे जल्दी से एक मॉडल बनाना जो सभी मध्यवर्ती परतों के आउटपुट को एक अनुक्रमिक संस्करण में निकालता है:

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)

यहां एक समान उदाहरण दिया गया है कि केवल एक परत से विशेषताएं निकाली जाती हैं:

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)

एक अनुक्रमिक मॉडल के साथ स्थानांतरण सीखने

ट्रांसफर लर्निंग में एक मॉडल में निचली परतों को ठंड करना और केवल ऊपरी परतों को प्रशिक्षित करना शामिल है। यदि आप इससे परिचित नहीं हैं, तो सीखने को स्थानांतरित करने के लिए हमारे गाइड को पढ़ना सुनिश्चित करें।

यहाँ अनुक्रमिक मॉडल से जुड़े दो सामान्य हस्तांतरण ब्लूप्रिंट सीख रहे हैं।

पहले, मान लें कि आपके पास एक अनुक्रमिक मॉडल है, और आप पिछले एक को छोड़कर सभी परतों को फ्रीज करना चाहते हैं। इस मामले में, आप बस पुनरावृति से अधिक होगा model.layers और सेट layer.trainable = False हर परत पर, पिछले एक को छोड़कर। इस कदर:

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

एक अन्य सामान्य खाका एक पूर्व-प्रशिक्षित मॉडल और कुछ ताज़ा प्रारंभिक वर्गीकरण परतों को ढेर करने के लिए एक अनुक्रमिक मॉडल का उपयोग करना है। इस कदर:

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

यदि आप ट्रांसफर लर्निंग करते हैं, तो आप शायद इन दो पैटर्नों का उपयोग करके खुद को अक्सर पाएंगे।

यह आप सभी के बारे में अनुक्रमिक मॉडल के बारे में जानने की जरूरत है!

केरस में मॉडल बनाने के बारे में और जानने के लिए देखें: