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

কাস্টম স্তর

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

আমরা নিউরাল নেটওয়ার্ক তৈরির জন্য একটি উচ্চ-স্তরের API হিসাবে tf.keras ব্যবহার করার পরামর্শ দিই। তাতে বলা হয়েছে, বেশিরভাগ টেনসরফ্লো এপিআই আগ্রহের সাথে কার্যকর করা যায়।

import tensorflow as tf
print(tf.config.list_physical_devices('GPU'))
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

স্তর: দরকারী অপারেশন সাধারণ সেট

বেশিরভাগ সময় মেশিন লার্নিং মডেলের জন্য কোড লেখার সময় আপনি স্বতন্ত্র ক্রিয়াকলাপ এবং পৃথক ভেরিয়েবলের ম্যানিপুলেশনের চেয়ে বিমূর্ততার উচ্চ স্তরে কাজ করতে চান।

অনেক মেশিন লার্নিং মডেল তুলনামূলকভাবে সহজ স্তরগুলির রচনা এবং স্ট্যাকিং হিসাবে প্রকাশযোগ্য, এবং TensorFlow অনেকগুলি সাধারণ স্তরগুলির একটি সেট এবং সেইসাথে আপনার নিজের অ্যাপ্লিকেশন-নির্দিষ্ট স্তরগুলিকে স্ক্র্যাচ থেকে বা এর রচনা হিসাবে লিখতে সহজ উপায় উভয়ই প্রদান করে। বিদ্যমান স্তর।

টেনসরফ্লো tf.keras প্যাকেজে সম্পূর্ণ Keras API অন্তর্ভুক্ত করে এবং কেরাস স্তরগুলি আপনার নিজের মডেলগুলি তৈরি করার সময় খুব দরকারী।

# In the tf.keras.layers package, layers are objects. To construct a layer,
# simply construct the object. Most layers take as a first argument the number
# of output dimensions / channels.
layer = tf.keras.layers.Dense(100)
# The number of input dimensions is often unnecessary, as it can be inferred
# the first time the layer is used, but it can be provided if you want to
# specify it manually, which is useful in some complex models.
layer = tf.keras.layers.Dense(10, input_shape=(None, 5))

প্রাক-বিদ্যমান স্তরগুলির সম্পূর্ণ তালিকা ডকুমেন্টেশনে দেখা যেতে পারে। এতে রয়েছে ঘন (একটি সম্পূর্ণ-সংযুক্ত স্তর), Conv2D, LSTM, BatchNormalization, Dropout, এবং আরও অনেক কিছু।

# To use a layer, simply call it.
layer(tf.zeros([10, 5]))
<tf.Tensor: shape=(10, 10), dtype=float32, numpy=
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>
# Layers have many useful methods. For example, you can inspect all variables
# in a layer using `layer.variables` and trainable variables using
# `layer.trainable_variables`. In this case a fully-connected layer
# will have variables for weights and biases.
layer.variables
[<tf.Variable 'dense_1/kernel:0' shape=(5, 10) dtype=float32, numpy=
 array([[-0.4370762 ,  0.6231566 , -0.44082257, -0.48535   ,  0.17860883,
         -0.521853  , -0.45774594, -0.5409817 ,  0.29194772, -0.18690601],
        [ 0.3304953 , -0.27142242, -0.48322448, -0.19328138, -0.14415592,
          0.05973059,  0.56227285,  0.5323917 , -0.4914217 ,  0.62182254],
        [-0.5313885 ,  0.54680306,  0.1632638 , -0.10741419, -0.04727739,
         -0.35414204,  0.07529551, -0.06515282, -0.19732419,  0.25217015],
        [ 0.49743277,  0.31172627,  0.04989761,  0.1200847 ,  0.42642146,
          0.5887727 ,  0.5771937 ,  0.08720696,  0.43024355, -0.17298424],
        [-0.07610255,  0.04131562,  0.3136508 , -0.6197298 ,  0.2331146 ,
          0.04888463, -0.54215366,  0.41208786,  0.27439958,  0.08524591]],
       dtype=float32)>,
 <tf.Variable 'dense_1/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>]
# The variables are also accessible through nice accessors
layer.kernel, layer.bias
(<tf.Variable 'dense_1/kernel:0' shape=(5, 10) dtype=float32, numpy=
 array([[-0.4370762 ,  0.6231566 , -0.44082257, -0.48535   ,  0.17860883,
         -0.521853  , -0.45774594, -0.5409817 ,  0.29194772, -0.18690601],
        [ 0.3304953 , -0.27142242, -0.48322448, -0.19328138, -0.14415592,
          0.05973059,  0.56227285,  0.5323917 , -0.4914217 ,  0.62182254],
        [-0.5313885 ,  0.54680306,  0.1632638 , -0.10741419, -0.04727739,
         -0.35414204,  0.07529551, -0.06515282, -0.19732419,  0.25217015],
        [ 0.49743277,  0.31172627,  0.04989761,  0.1200847 ,  0.42642146,
          0.5887727 ,  0.5771937 ,  0.08720696,  0.43024355, -0.17298424],
        [-0.07610255,  0.04131562,  0.3136508 , -0.6197298 ,  0.2331146 ,
          0.04888463, -0.54215366,  0.41208786,  0.27439958,  0.08524591]],
       dtype=float32)>,
 <tf.Variable 'dense_1/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>)

কাস্টম স্তর বাস্তবায়ন

আপনার নিজস্ব স্তর বাস্তবায়নের সর্বোত্তম উপায় হল tf.keras.Layer ক্লাস প্রসারিত করা এবং বাস্তবায়ন করা:

  1. __init__ , যেখানে আপনি সমস্ত ইনপুট-স্বাধীন আরম্ভ করতে পারেন
  2. build , যেখানে আপনি ইনপুট টেনসরের আকার জানেন এবং বাকিটা শুরু করতে পারেন
  3. call , যেখানে আপনি ফরোয়ার্ড গণনা করবেন

মনে রাখবেন যে আপনার ভেরিয়েবলগুলি তৈরি করতে build কল না হওয়া পর্যন্ত আপনাকে অপেক্ষা করতে হবে না, আপনি সেগুলি __init__ এও তৈরি করতে পারেন। যাইহোক, এগুলিকে build তৈরি করার সুবিধা হল যে এটি লেয়ারটি যে ইনপুটগুলিতে কাজ করবে তার আকৃতির উপর ভিত্তি করে দেরী পরিবর্তনশীল তৈরি করতে সক্ষম করে। অন্যদিকে, __init__ এ ভেরিয়েবল তৈরি করার অর্থ হল ভেরিয়েবল তৈরি করার জন্য প্রয়োজনীয় আকারগুলি স্পষ্টভাবে নির্দিষ্ট করা প্রয়োজন।

class MyDenseLayer(tf.keras.layers.Layer):
  def __init__(self, num_outputs):
    super(MyDenseLayer, self).__init__()
    self.num_outputs = num_outputs

  def build(self, input_shape):
    self.kernel = self.add_weight("kernel",
                                  shape=[int(input_shape[-1]),
                                         self.num_outputs])

  def call(self, inputs):
    return tf.matmul(inputs, self.kernel)

layer = MyDenseLayer(10)
_ = layer(tf.zeros([10, 5])) # Calling the layer `.builds` it.
print([var.name for var in layer.trainable_variables])
['my_dense_layer/kernel:0']

সামগ্রিক কোড পড়া এবং বজায় রাখা সহজ যদি এটি যখনই সম্ভব স্ট্যান্ডার্ড স্তর ব্যবহার করে, কারণ অন্যান্য পাঠকরা স্ট্যান্ডার্ড স্তরগুলির আচরণের সাথে পরিচিত হবেন। আপনি যদি এমন একটি স্তর ব্যবহার করতে চান যা tf.keras.layers এ উপস্থিত নেই, তাহলে একটি গিথুব সমস্যা ফাইল করার কথা বিবেচনা করুন বা আরও ভাল, আমাদের একটি পুল অনুরোধ পাঠান!

মডেল: রচনা স্তর

মেশিন লার্নিং মডেলে অনেক আকর্ষণীয় স্তর-সদৃশ জিনিস বিদ্যমান স্তরগুলি রচনা করে প্রয়োগ করা হয়। উদাহরণস্বরূপ, একটি রেসনেটের প্রতিটি অবশিষ্ট ব্লক হল কনভল্যুশন, ব্যাচ স্বাভাবিককরণ এবং একটি শর্টকাটের একটি সংমিশ্রণ। স্তরগুলি অন্যান্য স্তরের ভিতরে নেস্ট করা যেতে পারে।

সাধারণত আপনি keras.Model থেকে উত্তরাধিকারী হন যখন আপনার মডেল পদ্ধতির প্রয়োজন হয়: Model.fit , Model.evaluate , এবং Model.save (বিশদ বিবরণের জন্য কাস্টম কেরাস স্তর এবং মডেল দেখুন)।

keras.Model keras.layers.Layer পরিবর্তে) হল যে ভেরিয়েবলগুলিকে ট্র্যাক করার পাশাপাশি, একটি keras.Model এর অভ্যন্তরীণ স্তরগুলিকেও ট্র্যাক করে, যাতে তাদের পরীক্ষা করা সহজ হয়৷

উদাহরণস্বরূপ এখানে একটি ResNet ব্লক রয়েছে:

class ResnetIdentityBlock(tf.keras.Model):
  def __init__(self, kernel_size, filters):
    super(ResnetIdentityBlock, self).__init__(name='')
    filters1, filters2, filters3 = filters

    self.conv2a = tf.keras.layers.Conv2D(filters1, (1, 1))
    self.bn2a = tf.keras.layers.BatchNormalization()

    self.conv2b = tf.keras.layers.Conv2D(filters2, kernel_size, padding='same')
    self.bn2b = tf.keras.layers.BatchNormalization()

    self.conv2c = tf.keras.layers.Conv2D(filters3, (1, 1))
    self.bn2c = tf.keras.layers.BatchNormalization()

  def call(self, input_tensor, training=False):
    x = self.conv2a(input_tensor)
    x = self.bn2a(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2b(x)
    x = self.bn2b(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2c(x)
    x = self.bn2c(x, training=training)

    x += input_tensor
    return tf.nn.relu(x)


block = ResnetIdentityBlock(1, [1, 2, 3])
_ = block(tf.zeros([1, 2, 3, 3]))
block.layers
[<keras.layers.convolutional.Conv2D at 0x7fc7e439bf90>,
 <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7fc7dc1e5dd0>,
 <keras.layers.convolutional.Conv2D at 0x7fc7dc1a1cd0>,
 <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7fc7dc12c490>,
 <keras.layers.convolutional.Conv2D at 0x7fc7dc12c8d0>,
 <keras.layers.normalization.batch_normalization.BatchNormalization at 0x7fc7dc12cf50>]
len(block.variables)
18
block.summary()
Model: ""
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             multiple                  4         
                                                                 
 batch_normalization (BatchN  multiple                 4         
 ormalization)                                                   
                                                                 
 conv2d_1 (Conv2D)           multiple                  4         
                                                                 
 batch_normalization_1 (Batc  multiple                 8         
 hNormalization)                                                 
                                                                 
 conv2d_2 (Conv2D)           multiple                  9         
                                                                 
 batch_normalization_2 (Batc  multiple                 12        
 hNormalization)                                                 
                                                                 
=================================================================
Total params: 41
Trainable params: 29
Non-trainable params: 12
_________________________________________________________________

বেশিরভাগ সময়, যাইহোক, যে মডেলগুলি অনেকগুলি স্তর রচনা করে সেগুলি কেবল একের পর এক স্তরকে কল করে। এটি tf.keras.Sequential ব্যবহার করে খুব কম কোডে করা যেতে পারে:

my_seq = tf.keras.Sequential([tf.keras.layers.Conv2D(1, (1, 1),
                                                    input_shape=(
                                                        None, None, 3)),
                             tf.keras.layers.BatchNormalization(),
                             tf.keras.layers.Conv2D(2, 1,
                                                    padding='same'),
                             tf.keras.layers.BatchNormalization(),
                             tf.keras.layers.Conv2D(3, (1, 1)),
                             tf.keras.layers.BatchNormalization()])
my_seq(tf.zeros([1, 2, 3, 3]))
<tf.Tensor: shape=(1, 2, 3, 3), dtype=float32, numpy=
array([[[[0., 0., 0.],
         [0., 0., 0.],
         [0., 0., 0.]],

        [[0., 0., 0.],
         [0., 0., 0.],
         [0., 0., 0.]]]], dtype=float32)>
my_seq.summary()
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_3 (Conv2D)           (None, None, None, 1)     4         
                                                                 
 batch_normalization_3 (Batc  (None, None, None, 1)    4         
 hNormalization)                                                 
                                                                 
 conv2d_4 (Conv2D)           (None, None, None, 2)     4         
                                                                 
 batch_normalization_4 (Batc  (None, None, None, 2)    8         
 hNormalization)                                                 
                                                                 
 conv2d_5 (Conv2D)           (None, None, None, 3)     9         
                                                                 
 batch_normalization_5 (Batc  (None, None, None, 3)    12        
 hNormalization)                                                 
                                                                 
=================================================================
Total params: 41
Trainable params: 29
Non-trainable params: 12
_________________________________________________________________

পরবর্তী পদক্ষেপ

এখন আপনি আগের নোটবুকে ফিরে যেতে পারেন এবং রৈখিক রিগ্রেশন উদাহরণটি মানিয়ে নিতে পারেন স্তর এবং মডেলগুলিকে আরও ভাল কাঠামোর জন্য ব্যবহার করতে।