সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

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

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

সেটআপ

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

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

একটি Sequential মডেল স্তর একটি প্লেইন স্ট্যাকের যেখানে প্রতিটি স্তর ঠিক একটি ইনপুট টেন্সর এবং এক আউটপুট টেন্সর হয়েছে জন্য উপযুক্ত।

Schematically, নিম্নলিখিত 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
[<keras.layers.core.Dense at 0x7fdc784478d0>,
 <keras.layers.core.Dense at 0x7fdbbc3c4650>,
 <keras.layers.core.Dense at 0x7fdbbc3c4a10>]

এছাড়াও আপনি মাধ্যমে অতিরিক্ত হিসাবে অনুক্রমিক মডেল তৈরি করতে পারেন 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 মাত্র Keras কোনো স্তর বা মডেল মত যুক্তি। শব্দার্থগতভাবে অর্থপূর্ণ নামের সাথে 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.5319189 , -0.8767905 , -0.63919735],
        [-0.6276014 ,  0.1689707 , -0.57695866],
        [ 0.6710613 ,  0.5354214 , -0.00893992],
        [ 0.15670097, -0.15280598,  0.8865864 ]], dtype=float32)>,
 <tf.Variable 'dense_6/bias:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]

স্বাভাবিকভাবেই, এটি অনুক্রমিক মডেলের ক্ষেত্রেও প্রযোজ্য। আপনি যখন একটি ইনপুট আকৃতি, তাই না "নির্মিত" হয় ছাড়া একটি অনুক্রমিক মডেল instantiate: এটা কোন ওজন আছে (এবং কলিং 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
[<keras.layers.core.Dense at 0x7fdbbc37c390>]

একটি সহজ বিকল্প শুধু একটি পাস হয় 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 স্তর ইমেজ বৈশিষ্ট্য মানচিত্র downsampling হয়:

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)

একটি অনুক্রমিক মডেলের সাথে শিক্ষা স্থানান্তর করুন

ট্রান্সফার লার্নিং হল একটি মডেলের নীচের স্তরগুলিকে হিমায়িত করা এবং শুধুমাত্র উপরের স্তরগুলিকে প্রশিক্ষণ দেওয়া। আপনি এটা সাথে পরিচিত না হন, তাহলে আমাদের পড়া নিশ্চিত করা স্থানান্তর শেখার পথ প্রদর্শক

এখানে দুটি সাধারণ ট্রান্সফার লার্নিং ব্লুপ্রিন্ট রয়েছে যার মধ্যে সিকোয়েন্সিয়াল মডেল রয়েছে।

প্রথমে, ধরা যাক যে আপনার কাছে একটি অনুক্রমিক মডেল রয়েছে এবং আপনি শেষটি ব্যতীত সমস্ত স্তর হিমায়িত করতে চান। এই ক্ষেত্রে, আপনি কেবল বারবার উপর would 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(...)

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

সিকোয়েন্সিয়াল মডেল সম্পর্কে আপনার যা জানা দরকার তা হল!

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