আপনার স্থানীয় টেনসরফ্লো সর্বত্র সর্বত্র ইভেন্টের জন্য আরএসভিপি!
This page was translated by the Cloud Translation API.
Switch to English

সিক্যুয়ালিয়াল মডেল

টেনসরফ্লো.অর্গ.এ দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

সেটআপ

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

সিক্যুয়াল মডেলটি কখন ব্যবহার করবেন

Sequential মডেলটি স্তরগুলির একটি সাধারণ স্ট্যাকের জন্য উপযুক্ত যেখানে প্রতিটি স্তরে হুবহু একটি ইনপুট টেনসর এবং একটি আউটপুট টেন্সর থাকে or

স্কিম্যাটিকভাবে, নিম্নলিখিত 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 0x7f015f070ba8>,
 <tensorflow.python.keras.layers.core.Dense at 0x7f015c108eb8>,
 <tensorflow.python.keras.layers.core.Dense at 0x7f015c127048>]

আপনি 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 যুক্তি গ্রহণ করে। শব্দার্থগত অর্থপূর্ণ নাম সহ টেনসরবোর্ড গ্রাফগুলি টীকায়িত করতে এটি দরকারী।

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.00171375, -0.09715968, -0.6551091 ],
        [-0.30443102,  0.17899084,  0.46226573],
        [ 0.43442976, -0.26263595, -0.02547961],
        [ 0.1350286 , -0.5042394 ,  0.6228728 ]], 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 0x7f015c127dd8>]

একটি সহজ বিকল্প হ'ল কেবল আপনার প্রথম স্তরে একটি 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 2 Conv2D এবং MaxPooling2D 2 MaxPooling2D স্তরগুলির MaxPooling2D চিত্র বৈশিষ্ট্যের মানচিত্রকে 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 উপর model.layers পুনরাবৃত্তি করতে model.layers এবং layer.trainable = False ব্যতীত প্রতিটি স্তরে layer.trainable = False সেট 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(...)

আপনি যদি ট্রান্সফার লার্নিং করেন, আপনি সম্ভবত এই দুটি নিদর্শন ব্যবহার করে নিজেকে প্রায়শই খুঁজে পাবেন।

সিক্যুয়াল মডেল সম্পর্কে আপনার যা জানা দরকার তা কেবল এটিই!

কেরাসে বিল্ডিং মডেলগুলি সম্পর্কে আরও জানতে, দেখুন: