বেসিক ট্রেনিং লুপ

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

পূর্ববর্তী গাইডগুলিতে, আপনি টেনসর , ভেরিয়েবল , গ্রেডিয়েন্ট টেপ এবং মডিউল সম্পর্কে শিখেছেন। এই নির্দেশিকাতে, আপনি মডেলগুলিকে প্রশিক্ষণের জন্য এগুলি একসাথে ফিট করবেন।

TensorFlow এছাড়াও tf.Keras API অন্তর্ভুক্ত করে, একটি উচ্চ-স্তরের নিউরাল নেটওয়ার্ক API যা বয়লারপ্লেট কমাতে দরকারী বিমূর্ততা প্রদান করে। যাইহোক, এই গাইডে, আপনি মৌলিক ক্লাস ব্যবহার করবেন।

সেটআপ

import tensorflow as tf

import matplotlib.pyplot as plt

colors = plt.rcParams['axes.prop_cycle'].by_key()['color']

মেশিন লার্নিং সমস্যার সমাধান

একটি মেশিন লার্নিং সমস্যা সমাধানে সাধারণত নিম্নলিখিত ধাপগুলি থাকে:

• প্রশিক্ষণ তথ্য প্রাপ্ত.
• মডেল সংজ্ঞায়িত করুন।
• একটি ক্ষতি ফাংশন সংজ্ঞায়িত করুন।
• আদর্শ মান থেকে ক্ষতি গণনা করে প্রশিক্ষণ ডেটার মাধ্যমে চালান
• সেই ক্ষতির জন্য গ্রেডিয়েন্ট গণনা করুন এবং ডেটা ফিট করার জন্য ভেরিয়েবল সামঞ্জস্য করতে একটি অপ্টিমাইজার ব্যবহার করুন।
• আপনার ফলাফল মূল্যায়ন.

দৃষ্টান্তের উদ্দেশ্যে, এই গাইডে আপনি একটি সাধারণ রৈখিক মডেল তৈরি করবেন, \(f(x) = x * W + b\), যার দুটি ভেরিয়েবল রয়েছে: \(W\) (ওজন) এবং \(b\) (পক্ষপাত)।

এটি মেশিন লার্নিং সমস্যার সবচেয়ে মৌলিক: \(x\) এবং \(y\)দেওয়া, সরল লিনিয়ার রিগ্রেশনের মাধ্যমে একটি লাইনের ঢাল এবং অফসেট খুঁজে বের করার চেষ্টা করুন।

ডেটা

তত্ত্বাবধানে শিক্ষা ইনপুট (সাধারণত x হিসাবে চিহ্নিত করা হয়) এবং আউটপুট ( y দ্বারা চিহ্নিত করা হয়, প্রায়ই লেবেল বলা হয়) ব্যবহার করে। লক্ষ্য হল পেয়ার করা ইনপুট এবং আউটপুট থেকে শেখা যাতে আপনি একটি ইনপুট থেকে আউটপুটের মান অনুমান করতে পারেন।

আপনার ডেটার প্রতিটি ইনপুট, টেনসরফ্লোতে, প্রায় সবসময় একটি টেনসর দ্বারা প্রতিনিধিত্ব করা হয় এবং প্রায়শই একটি ভেক্টর হয়। তত্ত্বাবধানে প্রশিক্ষণে, আউটপুট (বা আপনি ভবিষ্যদ্বাণী করতে চান মান) এছাড়াও একটি টেনসর।

এখানে একটি লাইন বরাবর বিন্দুতে গাউসিয়ান (স্বাভাবিক) শব্দ যোগ করে সংশ্লেষিত কিছু ডেটা রয়েছে।

# The actual line
TRUE_W = 3.0
TRUE_B = 2.0

NUM_EXAMPLES = 201

# A vector of random x values
x = tf.linspace(-2,2, NUM_EXAMPLES)
x = tf.cast(x, tf.float32)

def f(x):
  return x * TRUE_W + TRUE_B

# Generate some noise
noise = tf.random.normal(shape=[NUM_EXAMPLES])

# Calculate y
y = f(x) + noise

# Plot all the data
plt.plot(x, y, '.')
plt.show()

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

মডেল সংজ্ঞায়িত করুন

একটি মডেলের সমস্ত ওজন উপস্থাপন করতে tf.Variable ব্যবহার করুন। একটি tf.Variable একটি মান সঞ্চয় করে এবং প্রয়োজন অনুসারে এটি টেনসর আকারে প্রদান করে। আরো বিস্তারিত জানার জন্য পরিবর্তনশীল গাইড দেখুন.

ভেরিয়েবল এবং গণনা এনক্যাপসুলেট করতে tf.Module ব্যবহার করুন। আপনি যেকোন পাইথন অবজেক্ট ব্যবহার করতে পারেন, কিন্তু এই ভাবে সহজেই সেভ করা যায়।

এখানে, আপনি পরিবর্তনশীল হিসাবে w এবং b উভয় সংজ্ঞায়িত করুন।

class MyModel(tf.Module):
  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # Initialize the weights to `5.0` and the bias to `0.0`
    # In practice, these should be randomly initialized
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  def __call__(self, x):
    return self.w * x + self.b

model = MyModel()

# List the variables tf.modules's built-in variable aggregation.
print("Variables:", model.variables)

# Verify the model works
assert model(3.0).numpy() == 15.0

Variables: (<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>, <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=5.0>)
2021-12-08 17:11:44.542944: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.

প্রাথমিক ভেরিয়েবলগুলি এখানে একটি নির্দিষ্ট উপায়ে সেট করা হয়েছে, তবে কেরাসের সাথে বাকী কেরাসের সাথে বা ছাড়াই আপনি ব্যবহার করতে পারেন এমন অনেকগুলি ইনিটালাইজারের সাথে আসে।

একটি ক্ষতি ফাংশন সংজ্ঞায়িত করুন

একটি ক্ষতি ফাংশন পরিমাপ করে যে প্রদত্ত ইনপুটের জন্য একটি মডেলের আউটপুট লক্ষ্য আউটপুটের সাথে কতটা মেলে। লক্ষ্য হল প্রশিক্ষণের সময় এই পার্থক্য কমিয়ে আনা। স্ট্যান্ডার্ড L2 ক্ষতি সংজ্ঞায়িত করুন, যা "মান বর্গ" ত্রুটি হিসাবেও পরিচিত:

# This computes a single loss value for an entire batch
def loss(target_y, predicted_y):
  return tf.reduce_mean(tf.square(target_y - predicted_y))

মডেলটিকে প্রশিক্ষণ দেওয়ার আগে, আপনি লাল রঙে মডেলের ভবিষ্যদ্বাণী এবং নীল রঙে প্রশিক্ষণের ডেটা প্লট করে ক্ষতির মান কল্পনা করতে পারেন:

plt.plot(x, y, '.', label="Data")
plt.plot(x, f(x), label="Ground truth")
plt.plot(x, model(x), label="Predictions")
plt.legend()
plt.show()

print("Current loss: %1.6f" % loss(y, model(x)).numpy())

Current loss: 10.301712

একটি প্রশিক্ষণ লুপ সংজ্ঞায়িত করুন

প্রশিক্ষণের লুপটি ক্রমানুসারে তিনটি কাজ বারবার করে থাকে:

• আউটপুট তৈরি করতে মডেলের মাধ্যমে ইনপুটগুলির একটি ব্যাচ পাঠানো
• আউটপুট (বা লেবেল) এর সাথে আউটপুট তুলনা করে ক্ষতি গণনা করা
• গ্রেডিয়েন্ট খুঁজে পেতে গ্রেডিয়েন্ট টেপ ব্যবহার করে
• সেই গ্রেডিয়েন্টগুলির সাথে ভেরিয়েবলগুলিকে অপ্টিমাইজ করা

এই উদাহরণের জন্য, আপনি গ্রেডিয়েন্ট ডিসেন্ট ব্যবহার করে মডেলটিকে প্রশিক্ষণ দিতে পারেন।

গ্রেডিয়েন্ট ডিসেন্ট স্কিমের অনেকগুলি রূপ রয়েছে যা tf.keras.optimizers এ ক্যাপচার করা হয়েছে। কিন্তু প্রথম নীতিগুলি থেকে গড়ে তোলার চেতনায়, এখানে আপনি স্বয়ংক্রিয় পার্থক্যের জন্য tf.GradientTape এবং একটি মান হ্রাস করার জন্য tf.assign_sub (যা tf.assign এবং tf.sub কে একত্রিত করে) এর সাহায্যে মৌলিক গণিতটি নিজেই বাস্তবায়ন করবেন :

# Given a callable model, inputs, outputs, and a learning rate...
def train(model, x, y, learning_rate):

  with tf.GradientTape() as t:
    # Trainable variables are automatically tracked by GradientTape
    current_loss = loss(y, model(x))

  # Use GradientTape to calculate the gradients with respect to W and b
  dw, db = t.gradient(current_loss, [model.w, model.b])

  # Subtract the gradient scaled by the learning rate
  model.w.assign_sub(learning_rate * dw)
  model.b.assign_sub(learning_rate * db)

প্রশিক্ষণের দিকে নজর দেওয়ার জন্য, আপনি প্রশিক্ষণ লুপের মাধ্যমে x এবং y- এর একই ব্যাচ পাঠাতে পারেন এবং দেখুন কিভাবে W এবং b বিবর্তিত হয়।

model = MyModel()

# Collect the history of W-values and b-values to plot later
weights = []
biases = []
epochs = range(10)

# Define a training loop
def report(model, loss):
  return f"W = {model.w.numpy():1.2f}, b = {model.b.numpy():1.2f}, loss={current_loss:2.5f}"


def training_loop(model, x, y):

  for epoch in epochs:
    # Update the model with the single giant batch
    train(model, x, y, learning_rate=0.1)

    # Track this before I update
    weights.append(model.w.numpy())
    biases.append(model.b.numpy())
    current_loss = loss(y, model(x))

    print(f"Epoch {epoch:2d}:")
    print("    ", report(model, current_loss))

প্রশিক্ষণ দিন

current_loss = loss(y, model(x))

print(f"Starting:")
print("    ", report(model, current_loss))

training_loop(model, x, y)

Starting:
     W = 5.00, b = 0.00, loss=10.30171
Epoch  0:
     W = 4.46, b = 0.40, loss=10.30171
Epoch  1:
     W = 4.06, b = 0.72, loss=10.30171
Epoch  2:
     W = 3.77, b = 0.97, loss=10.30171
Epoch  3:
     W = 3.56, b = 1.18, loss=10.30171
Epoch  4:
     W = 3.40, b = 1.34, loss=10.30171
Epoch  5:
     W = 3.29, b = 1.47, loss=10.30171
Epoch  6:
     W = 3.21, b = 1.58, loss=10.30171
Epoch  7:
     W = 3.15, b = 1.66, loss=10.30171
Epoch  8:
     W = 3.10, b = 1.73, loss=10.30171
Epoch  9:
     W = 3.07, b = 1.78, loss=10.30171

সময়ের সাথে ওজনের বিবর্তন প্লট করুন:

plt.plot(epochs, weights, label='Weights', color=colors[0])
plt.plot(epochs, [TRUE_W] * len(epochs), '--',
         label = "True weight", color=colors[0])

plt.plot(epochs, biases, label='bias', color=colors[1])
plt.plot(epochs, [TRUE_B] * len(epochs), "--",
         label="True bias", color=colors[1])

plt.legend()
plt.show()

প্রশিক্ষিত মডেলটি কীভাবে কাজ করে তা কল্পনা করুন

plt.plot(x, y, '.', label="Data")
plt.plot(x, f(x), label="Ground truth")
plt.plot(x, model(x), label="Predictions")
plt.legend()
plt.show()

print("Current loss: %1.6f" % loss(model(x), y).numpy())

Current loss: 0.897898

একই সমাধান, কিন্তু কেরাসের সাথে

কেরাসের সমতুল্যের সাথে উপরের কোডের বিপরীতে এটি কার্যকর।

আপনি tf.keras.Model সাবক্লাস করলে মডেলটিকে সংজ্ঞায়িত করা ঠিক একই রকম দেখায়। মনে রাখবেন যে কেরাস মডেলগুলি শেষ পর্যন্ত মডিউল থেকে উত্তরাধিকার সূত্রে প্রাপ্ত হয়।

class MyModelKeras(tf.keras.Model):
  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # Initialize the weights to `5.0` and the bias to `0.0`
    # In practice, these should be randomly initialized
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  def call(self, x):
    return self.w * x + self.b

keras_model = MyModelKeras()

# Reuse the training loop with a Keras model
training_loop(keras_model, x, y)

# You can also save a checkpoint using Keras's built-in support
keras_model.save_weights("my_checkpoint")

Epoch  0:
     W = 4.46, b = 0.40, loss=10.30171
Epoch  1:
     W = 4.06, b = 0.72, loss=10.30171
Epoch  2:
     W = 3.77, b = 0.97, loss=10.30171
Epoch  3:
     W = 3.56, b = 1.18, loss=10.30171
Epoch  4:
     W = 3.40, b = 1.34, loss=10.30171
Epoch  5:
     W = 3.29, b = 1.47, loss=10.30171
Epoch  6:
     W = 3.21, b = 1.58, loss=10.30171
Epoch  7:
     W = 3.15, b = 1.66, loss=10.30171
Epoch  8:
     W = 3.10, b = 1.73, loss=10.30171
Epoch  9:
     W = 3.07, b = 1.78, loss=10.30171

আপনি প্রতিবার একটি মডেল তৈরি করার সময় নতুন প্রশিক্ষণ লুপ লেখার পরিবর্তে, আপনি শর্টকাট হিসাবে কেরাসের অন্তর্নির্মিত বৈশিষ্ট্যগুলি ব্যবহার করতে পারেন। আপনি যখন পাইথন প্রশিক্ষণ লুপ লিখতে বা ডিবাগ করতে চান না তখন এটি কার্যকর হতে পারে।

যদি আপনি তা করেন, আপনাকে প্যারামিটার সেট করতে model.fit() এবং প্রশিক্ষণের জন্য model.fit( model.compile() ব্যবহার করতে হবে। আবার শর্টকাট হিসাবে L2 ক্ষতি এবং গ্রেডিয়েন্ট ডিসেন্টের কেরাস বাস্তবায়ন ব্যবহার করার জন্য এটি কম কোড হতে পারে। Keras ক্ষতি এবং অপ্টিমাইজারগুলি এই সুবিধার ফাংশনগুলির বাইরেও ব্যবহার করা যেতে পারে এবং পূর্ববর্তী উদাহরণটি সেগুলি ব্যবহার করতে পারে।

keras_model = MyModelKeras()

# compile sets the training parameters
keras_model.compile(
    # By default, fit() uses tf.function().  You can
    # turn that off for debugging, but it is on now.
    run_eagerly=False,

    # Using a built-in optimizer, configuring as an object
    optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),

    # Keras comes with built-in MSE error
    # However, you could use the loss function
    # defined above
    loss=tf.keras.losses.mean_squared_error,
)

কেরাস fit একটি NumPy অ্যারে হিসাবে ব্যাচ করা ডেটা বা একটি সম্পূর্ণ ডেটাসেট আশা করে৷ NumPy অ্যারেগুলি ব্যাচগুলিতে কাটা হয় এবং 32 ব্যাচের আকারে ডিফল্ট হয়।

এই ক্ষেত্রে, হাতে লেখা লুপের আচরণের সাথে মেলে, আপনার 1000 আকারের একক ব্যাচ হিসাবে x পাস করা উচিত।

print(x.shape[0])
keras_model.fit(x, y, epochs=10, batch_size=1000)

201
Epoch 1/10
1/1 [==============================] - 0s 242ms/step - loss: 10.3017
Epoch 2/10
1/1 [==============================] - 0s 3ms/step - loss: 6.3148
Epoch 3/10
1/1 [==============================] - 0s 3ms/step - loss: 4.0341
Epoch 4/10
1/1 [==============================] - 0s 3ms/step - loss: 2.7191
Epoch 5/10
1/1 [==============================] - 0s 3ms/step - loss: 1.9548
Epoch 6/10
1/1 [==============================] - 0s 2ms/step - loss: 1.5068
Epoch 7/10
1/1 [==============================] - 0s 3ms/step - loss: 1.2422
Epoch 8/10
1/1 [==============================] - 0s 2ms/step - loss: 1.0845
Epoch 9/10
1/1 [==============================] - 0s 2ms/step - loss: 0.9899
Epoch 10/10
1/1 [==============================] - 0s 3ms/step - loss: 0.9327
<keras.callbacks.History at 0x7f02ad940050>

মনে রাখবেন যে কেরাস প্রশিক্ষণের পরে ক্ষতি প্রিন্ট করে, আগে নয়, তাই প্রথম ক্ষতি কম দেখায়, কিন্তু অন্যথায় এটি মূলত একই প্রশিক্ষণ কার্যকারিতা দেখায়।

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

এই নির্দেশিকাটিতে, আপনি দেখেছেন কিভাবে টেনসর, ভেরিয়েবল, মডিউল এবং গ্রেডিয়েন্ট টেপের মূল ক্লাসগুলি একটি মডেল তৈরি ও প্রশিক্ষণের জন্য ব্যবহার করতে হয় এবং আরও কীভাবে এই ধারণাগুলি কেরাসে ম্যাপ করে।

তবে এটি একটি অত্যন্ত সহজ সমস্যা। আরও ব্যবহারিক ভূমিকার জন্য, কাস্টম ট্রেনিং ওয়াকথ্রু দেখুন।

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