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

অন্তর্নির্মিত পদ্ধতিগুলির সাথে প্রশিক্ষণ এবং মূল্যায়ন

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

সেটআপ

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

ভূমিকা

এই নির্দেশিকাটি কভার প্রশিক্ষণ, মূল্যায়ন, এবং Prediction (অনুমান) মডেলের যখন ব্যবহার বিল্ট ইন প্রশিক্ষণ ও বৈধতা (যেমন জন্য API গুলি Model.fit() , Model.evaluate() এবং Model.predict() )।

আপনি ওঠানামা আগ্রহী fit() আপনার নিজের প্রশিক্ষণ পদক্ষেপ ফাংশন উল্লেখ করার সময় দেখতে কাস্টমাইজ কি ঘটবে fit() পথপ্রদর্শক

আপনি স্ক্র্যাচ থেকে আপনার নিজের প্রশিক্ষণ ও মূল্যায়ন লুপ লিখিতভাবে আগ্রহী, নির্দেশিকাটি দেখুন "গোড়া থেকে একটি প্রশিক্ষণ লুপ লেখা"

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

এই নির্দেশিকাটি বিতরণ প্রশিক্ষণ, যা আমাদের মধ্যে আবৃত করা হয় কাভার করে না বহু-জিপিইউ ও বিতরণ প্রশিক্ষণ নির্দেশিকা

API ওভারভিউ: প্রথম এন্ড-টু-এন্ড উদাহরণ

যখন ডেটা ক্ষণস্থায়ী বিল্ট-ইন একটি মডেল লুপ প্রশিক্ষণ, হয় আপনি NumPy অ্যারে ব্যবহার করা উচিত (যদি আপনার ডেটা ছোট এবং মেমরি মধ্যে ফিট করে হয়) অথবা tf.data Dataset অবজেক্ট। পরের কয়েকটি অনুচ্ছেদে, আমরা MNIST ডেটাসেটটিকে NumPy অ্যারে হিসাবে ব্যবহার করব, যাতে অপ্টিমাইজার, ক্ষতি এবং মেট্রিক্স কীভাবে ব্যবহার করতে হয় তা প্রদর্শন করতে।

আসুন নিম্নলিখিত মডেলটি বিবেচনা করি (এখানে, আমরা কার্যকরী API দিয়ে তৈরি করি, তবে এটি একটি অনুক্রমিক মডেল বা একটি উপশ্রেণীর মডেলও হতে পারে):

inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, activation="softmax", name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)

সাধারণ এন্ড-টু-এন্ড ওয়ার্কফ্লো কেমন দেখায় তা এখানে রয়েছে, যার মধ্যে রয়েছে:

  • প্রশিক্ষণ
  • মূল প্রশিক্ষণ ডেটা থেকে তৈরি একটি হোল্ডআউট সেটের বৈধতা
  • পরীক্ষার তথ্য মূল্যায়ন

আমরা এই উদাহরণের জন্য MNIST ডেটা ব্যবহার করব।

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Preprocess the data (these are NumPy arrays)
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255

y_train = y_train.astype("float32")
y_test = y_test.astype("float32")

# Reserve 10,000 samples for validation
x_val = x_train[-10000:]
y_val = y_train[-10000:]
x_train = x_train[:-10000]
y_train = y_train[:-10000]

আমরা প্রশিক্ষণ কনফিগারেশন নির্দিষ্ট করি (অপ্টিমাইজার, ক্ষতি, মেট্রিক্স):

model.compile(
    optimizer=keras.optimizers.RMSprop(),  # Optimizer
    # Loss function to minimize
    loss=keras.losses.SparseCategoricalCrossentropy(),
    # List of metrics to monitor
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

আমরা কল fit() , যা আকারের "ব্যাচ" ডেটা slicing দ্বারা মডেল শেখাতে হবে batch_size , এবং বারবার একটি প্রদত্ত সংখ্যার জন্য সমগ্র ডেটা সেটটি উপর iterating epochs

print("Fit model on training data")
history = model.fit(
    x_train,
    y_train,
    batch_size=64,
    epochs=2,
    # We pass some validation for
    # monitoring validation loss and metrics
    # at the end of each epoch
    validation_data=(x_val, y_val),
)
Fit model on training data
Epoch 1/2
782/782 [==============================] - 3s 3ms/step - loss: 0.3387 - sparse_categorical_accuracy: 0.9050 - val_loss: 0.1957 - val_sparse_categorical_accuracy: 0.9426
Epoch 2/2
782/782 [==============================] - 2s 3ms/step - loss: 0.1543 - sparse_categorical_accuracy: 0.9548 - val_loss: 0.1425 - val_sparse_categorical_accuracy: 0.9593

ফিরে history বস্তুর প্রশিক্ষণের সময় হ্রাস মূল্যবোধ ও মেট্রিক মূল্যবোধের রেকর্ড:

history.history
{'loss': [0.3386789858341217, 0.1543138176202774],
 'sparse_categorical_accuracy': [0.9050400257110596, 0.9548400044441223],
 'val_loss': [0.19569723308086395, 0.14253544807434082],
 'val_sparse_categorical_accuracy': [0.9426000118255615, 0.9592999815940857]}

আমরা মাধ্যমে পরীক্ষা ডেটার উপর মডেল মূল্যায়ন evaluate() :

# Evaluate the model on the test data using `evaluate`
print("Evaluate on test data")
results = model.evaluate(x_test, y_test, batch_size=128)
print("test loss, test acc:", results)

# Generate predictions (probabilities -- the output of the last layer)
# on new data using `predict`
print("Generate predictions for 3 samples")
predictions = model.predict(x_test[:3])
print("predictions shape:", predictions.shape)
Evaluate on test data
79/79 [==============================] - 0s 2ms/step - loss: 0.1414 - sparse_categorical_accuracy: 0.9569
test loss, test acc: [0.14140386879444122, 0.9569000005722046]
Generate predictions for 3 samples
predictions shape: (3, 10)

এখন, এই কর্মপ্রবাহের প্রতিটি অংশ বিস্তারিতভাবে পর্যালোচনা করা যাক।

compile() পদ্ধতি: একটি ক্ষতি, মেট্রিক্স উল্লেখ, এবং একটি অপটিমাইজার

সঙ্গে একটি মডেল প্রশিক্ষণ দেওয়া fit() , আপনি একটি ক্ষতি ফাংশন, একটি অপটিমাইজার, এবং ঐচ্ছিকরূপে, মনিটর করার জন্য কিছু বৈশিষ্ট্যের মান নির্দিষ্ট করতে হবে।

তোমার আর্গুমেন্ট হিসাবে মডেল এইসব পাস compile() পদ্ধতি:

model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

metrics যুক্তি তালিকা হতে হবে - আপনার মডেল মেট্রিক্স যে কোন সংখ্যার থাকতে পারে।

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

মনে রাখবেন যে আপনি যদি ডিফল্ট সেটিংসের সাথে সন্তুষ্ট হন, অনেক ক্ষেত্রে অপ্টিমাইজার, ক্ষতি এবং মেট্রিক্স একটি শর্টকাট হিসাবে স্ট্রিং শনাক্তকারীর মাধ্যমে নির্দিষ্ট করা যেতে পারে:

model.compile(
    optimizer="rmsprop",
    loss="sparse_categorical_crossentropy",
    metrics=["sparse_categorical_accuracy"],
)

পরবর্তীতে পুনঃব্যবহারের জন্য, আসুন আমাদের মডেল সংজ্ঞা রাখি এবং ফাংশনে ধাপ কম্পাইল করি; আমরা এই নির্দেশিকায় বিভিন্ন উদাহরণ জুড়ে তাদের একাধিকবার কল করব।

def get_uncompiled_model():
    inputs = keras.Input(shape=(784,), name="digits")
    x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
    x = layers.Dense(64, activation="relu", name="dense_2")(x)
    outputs = layers.Dense(10, activation="softmax", name="predictions")(x)
    model = keras.Model(inputs=inputs, outputs=outputs)
    return model


def get_compiled_model():
    model = get_uncompiled_model()
    model.compile(
        optimizer="rmsprop",
        loss="sparse_categorical_crossentropy",
        metrics=["sparse_categorical_accuracy"],
    )
    return model

অনেক অন্তর্নির্মিত অপ্টিমাইজার, ক্ষতি, এবং মেট্রিক্স উপলব্ধ

সাধারণভাবে, আপনাকে স্ক্র্যাচ থেকে আপনার নিজের ক্ষতি, মেট্রিক্স বা অপ্টিমাইজার তৈরি করতে হবে না, কারণ আপনার যা প্রয়োজন তা ইতিমধ্যেই কেরাস API এর অংশ হতে পারে:

অপ্টিমাইজার:

  • SGD() (সহ বা ভরবেগ ছাড়া)
  • RMSprop()
  • Adam()
  • ইত্যাদি

ক্ষতি:

  • MeanSquaredError()
  • KLDivergence()
  • CosineSimilarity()
  • ইত্যাদি

মেট্রিক্স:

  • AUC()
  • Precision()
  • Recall()
  • ইত্যাদি

কাস্টম লোকসান

আপনার যদি একটি কাস্টম ক্ষতি তৈরি করতে হয়, কেরাস এটি করার দুটি উপায় সরবরাহ করে।

প্রথম পদ্ধতি একটি ফাংশন যে ইনপুট গ্রহণ তৈরি জড়িত y_true এবং y_pred । নিম্নলিখিত উদাহরণটি একটি ক্ষতি ফাংশন দেখায় যা প্রকৃত ডেটা এবং ভবিষ্যদ্বাণীগুলির মধ্যে গড় বর্গক্ষেত্র ত্রুটি গণনা করে:

def custom_mean_squared_error(y_true, y_pred):
    return tf.math.reduce_mean(tf.square(y_true - y_pred))


model = get_uncompiled_model()
model.compile(optimizer=keras.optimizers.Adam(), loss=custom_mean_squared_error)

# We need to one-hot encode the labels to use MSE
y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.0162
<keras.callbacks.History at 0x7ff8881ba250>

আপনি একটি ক্ষতি ফাংশন যা পাশে পরামিতি লাগে প্রয়োজন y_true এবং y_pred , আপনি উপশ্রেণী করতে tf.keras.losses.Loss বর্গ এবং নিম্নলিখিত দুটি পদ্ধতি বাস্তবায়ন:

  • __init__(self) : পরামিতি গ্রহণ আপনার ক্ষতির ফাংশনের কলের সময় পাস করার
  • call(self, y_true, y_pred) : লক্ষ্যমাত্রা (y_true) এবং মডেল ভবিষ্যৎবাণী (y_pred) মডেলের ক্ষতি গনা ব্যবহার

ধরা যাক আপনি গড় বর্গাকার ত্রুটি ব্যবহার করতে চান, তবে একটি অতিরিক্ত শব্দের সাথে যা 0.5 থেকে অনেক দূরে পূর্বাভাস মানগুলিকে ডি-ইনসেন্টিভাইজ করবে (আমরা ধরে নিই যে শ্রেণীবদ্ধ লক্ষ্যগুলি এক-হট এনকোডেড এবং 0 এবং 1 এর মধ্যে মান নেয়)। এটি মডেলকে খুব বেশি আত্মবিশ্বাসী না হওয়ার জন্য একটি প্রণোদনা তৈরি করে, যা অতিরিক্ত ফিটিং কমাতে সাহায্য করতে পারে (আমরা চেষ্টা না করা পর্যন্ত এটি কাজ করে কিনা তা আমরা জানব না!)

আপনি এটি কীভাবে করবেন তা এখানে:

class CustomMSE(keras.losses.Loss):
    def __init__(self, regularization_factor=0.1, name="custom_mse"):
        super().__init__(name=name)
        self.regularization_factor = regularization_factor

    def call(self, y_true, y_pred):
        mse = tf.math.reduce_mean(tf.square(y_true - y_pred))
        reg = tf.math.reduce_mean(tf.square(0.5 - y_pred))
        return mse + reg * self.regularization_factor


model = get_uncompiled_model()
model.compile(optimizer=keras.optimizers.Adam(), loss=CustomMSE())

y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.0388
<keras.callbacks.History at 0x7ff8882130d0>

কাস্টম মেট্রিক্স

আপনি যদি একটি মেট্রিক যে API- এর অংশ নয় প্রয়োজন হয়, তাহলে আপনি সহজেই subclassing এর পক্ষ থেকে কাস্টম মেট্রিক্স তৈরি করতে পারেন tf.keras.metrics.Metric বর্গ। আপনাকে 4টি পদ্ধতি প্রয়োগ করতে হবে:

  • __init__(self) , যা আপনি আপনার মেট্রিক জন্য রাষ্ট্র ভেরিয়েবল তৈরি করবে।
  • update_state(self, y_true, y_pred, sample_weight=None) , যা ব্যবহার করে লক্ষ্যমাত্রা y_true এবং মডেল ভবিষ্যৎবাণী রাষ্ট্র ভেরিয়েবল আপডেট করতে y_pred।
  • result(self) , যা চূড়ান্ত ফলাফল গনা রাষ্ট্র ভেরিয়েবল ব্যবহার করে।
  • reset_state(self) , যা মেট্রিক রাজ্যের reinitializes।

রাজ্য আপডেট এবং ফলাফল গণনার পৃথক (রাখা হয় update_state() এবং result() যথাক্রমে) কারণ কিছু ক্ষেত্রে, ফলাফল গণনার খুব ব্যয়বহুল হতে পারে এবং শুধুমাত্র পর্যায়ক্রমে সম্পন্ন করা হবে।

এখানে একটি সহজ কিভাবে বাস্তবায়ন দেখাচ্ছে উদাহরণ CategoricalTruePositives মেট্রিক মোট ছাত্র যে কত নমুনা সঠিকভাবে একটা নির্দিষ্ট ক্লাস একাত্মতার হিসাবে শ্রেণীবদ্ধ করা হয়েছে:

class CategoricalTruePositives(keras.metrics.Metric):
    def __init__(self, name="categorical_true_positives", **kwargs):
        super(CategoricalTruePositives, self).__init__(name=name, **kwargs)
        self.true_positives = self.add_weight(name="ctp", initializer="zeros")

    def update_state(self, y_true, y_pred, sample_weight=None):
        y_pred = tf.reshape(tf.argmax(y_pred, axis=1), shape=(-1, 1))
        values = tf.cast(y_true, "int32") == tf.cast(y_pred, "int32")
        values = tf.cast(values, "float32")
        if sample_weight is not None:
            sample_weight = tf.cast(sample_weight, "float32")
            values = tf.multiply(values, sample_weight)
        self.true_positives.assign_add(tf.reduce_sum(values))

    def result(self):
        return self.true_positives

    def reset_state(self):
        # The state of the metric will be reset at the start of each epoch.
        self.true_positives.assign(0.0)


model = get_uncompiled_model()
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=[CategoricalTruePositives()],
)
model.fit(x_train, y_train, batch_size=64, epochs=3)
Epoch 1/3
782/782 [==============================] - 2s 3ms/step - loss: 0.3404 - categorical_true_positives: 45217.0000
Epoch 2/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1588 - categorical_true_positives: 47606.0000
Epoch 3/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1168 - categorical_true_positives: 48278.0000
<keras.callbacks.History at 0x7ff8880a3610>

মানসম্মত স্বাক্ষরের সাথে খাপ খায় না এমন ক্ষতি এবং মেট্রিক্স পরিচালনা করা

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

এই ক্ষেত্রে, আপনি কল করতে পারেন self.add_loss(loss_value) একটি কাস্টম স্তর কল পদ্ধতি ভিতর থেকে। এই ভাবে যোগ লোকসান প্রশিক্ষণের সময় "মেন" ক্ষতি যুক্ত হয়ে (এক প্রেরণ compile() )। এখানে একটি সাধারণ উদাহরণ যা ক্রিয়াকলাপ নিয়মিতকরণ যোগ করে (মনে রাখবেন যে কার্যকলাপ নিয়মিতকরণ সমস্ত কেরাস স্তরগুলিতে অন্তর্নির্মিত - এই স্তরটি কেবল একটি নির্দিষ্ট উদাহরণ প্রদানের জন্য):

class ActivityRegularizationLayer(layers.Layer):
    def call(self, inputs):
        self.add_loss(tf.reduce_sum(inputs) * 0.1)
        return inputs  # Pass-through layer.


inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)

# Insert activity regularization as a layer
x = ActivityRegularizationLayer()(x)

x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)

# The displayed loss will be much higher than before
# due to the regularization component.
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 2.4545
<keras.callbacks.History at 0x7ff87c53f310>

আপনি মেট্রিক মান লগ-ইন, ব্যবহার করার জন্য একই কাজ করতে পারেন add_metric() :

class MetricLoggingLayer(layers.Layer):
    def call(self, inputs):
        # The `aggregation` argument defines
        # how to aggregate the per-batch values
        # over each epoch:
        # in this case we simply average them.
        self.add_metric(
            keras.backend.std(inputs), name="std_of_activation", aggregation="mean"
        )
        return inputs  # Pass-through layer.


inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)

# Insert std logging as a layer.
x = MetricLoggingLayer()(x)

x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.3461 - std_of_activation: 0.9929
<keras.callbacks.History at 0x7ff87c3d5bd0>

ইন ক্রিয়াগত এপিআই , এছাড়াও আপনি কল করতে পারেন model.add_loss(loss_tensor) , অথবা model.add_metric(metric_tensor, name, aggregation)

এখানে একটি সহজ উদাহরণ:

inputs = keras.Input(shape=(784,), name="digits")
x1 = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x2 = layers.Dense(64, activation="relu", name="dense_2")(x1)
outputs = layers.Dense(10, name="predictions")(x2)
model = keras.Model(inputs=inputs, outputs=outputs)

model.add_loss(tf.reduce_sum(x1) * 0.1)

model.add_metric(keras.backend.std(x1), name="std_of_activation", aggregation="mean")

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 3ms/step - loss: 2.4647 - std_of_activation: 0.0017
<keras.callbacks.History at 0x7ff87c216f90>

মনে রাখবেন আপনি যখন মাধ্যমে লোকসান পাস add_loss() , এটা কলে সম্ভব হয়ে ওঠে compile() একটি ক্ষতি ফাংশন ছাড়া, যেহেতু মডেল ইতিমধ্যে কমানোর জন্য একটি ক্ষতি হয়েছে।

বিবেচনা করুন নিম্নলিখিত LogisticEndpoint স্তর: এটা ইনপুট লক্ষ্যমাত্রা & logits যেমন নেয় এবং এর মাধ্যমে একটি crossentropy ক্ষতি ট্র্যাক add_loss() । এছাড়া মাধ্যমে শ্রেণীবিন্যাস সঠিকতা ট্র্যাক add_metric()

class LogisticEndpoint(keras.layers.Layer):
    def __init__(self, name=None):
        super(LogisticEndpoint, self).__init__(name=name)
        self.loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)
        self.accuracy_fn = keras.metrics.BinaryAccuracy()

    def call(self, targets, logits, sample_weights=None):
        # Compute the training-time loss value and add it
        # to the layer using `self.add_loss()`.
        loss = self.loss_fn(targets, logits, sample_weights)
        self.add_loss(loss)

        # Log accuracy as a metric and add it
        # to the layer using `self.add_metric()`.
        acc = self.accuracy_fn(targets, logits, sample_weights)
        self.add_metric(acc, name="accuracy")

        # Return the inference-time prediction tensor (for `.predict()`).
        return tf.nn.softmax(logits)

আপনি দুটি কেনে (ইনপুট ডেটা & লক্ষ্যমাত্রা), একটি ছাড়া কম্পাইল সঙ্গে একটি মডেল মধ্যে এটি ব্যবহার করতে পারেন loss যুক্তি, এভাবে:

import numpy as np

inputs = keras.Input(shape=(3,), name="inputs")
targets = keras.Input(shape=(10,), name="targets")
logits = keras.layers.Dense(10)(inputs)
predictions = LogisticEndpoint(name="predictions")(logits, targets)

model = keras.Model(inputs=[inputs, targets], outputs=predictions)
model.compile(optimizer="adam")  # No loss argument!

data = {
    "inputs": np.random.random((3, 3)),
    "targets": np.random.random((3, 10)),
}
model.fit(data)
1/1 [==============================] - 0s 414ms/step - loss: 0.9889 - binary_accuracy: 0.0000e+00
<keras.callbacks.History at 0x7ff87c0848d0>

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

স্বয়ংক্রিয়ভাবে একটি বৈধতা হোল্ডআউট সেট আলাদা করে

প্রথম এন্ড-টু-এন্ড উদাহরণ তোমাকে দেখেছিলাম, আমরা ব্যবহৃত validation_data NumPy অ্যারে একটি tuple পাস যুক্তি (x_val, y_val) প্রতিটি যুগে শেষে একটি বৈধতা কমে যাওয়া এবং বৈধতা মেট্রিক্স মূল্যায়নের জন্য মডেল হতে।

এখানে অন্য কোনো বিকল্প আছে: যুক্তি validation_split পারবেন আপনি যাচাইকরণের জন্য আপনার প্রশিক্ষণ ডেটার স্বয়ংক্রিয়ভাবে রিজার্ভ অংশ। যুক্তি মান তাই এটি, 0 বেশী একটি সংখ্যা এ সেট করা উচিত চেয়ে 1. উদাহরণস্বরূপ কম, বৈধতা জন্য সংরক্ষিত করা ডেটার ভগ্নাংশ প্রতিনিধিত্ব করে validation_split=0.2 মানে হলো "ব্যবহার বৈধতা জন্য তথ্য 20%", এবং validation_split=0.6 মানে হলো "ব্যবহার বৈধতা জন্য তথ্য 60%"।

পথ বৈধতা নির্ণয় করা হয় দ্বারা গৃহীত অ্যারে শেষ এক্স% নমুনা গ্রহণ করে হয় fit() , কল কোনো প্রকাশের shuffling আগে।

মনে রাখবেন আপনি শুধুমাত্র ব্যবহার করতে পারেন validation_split যখন NumPy ডেটার সাথে প্রশিক্ষণ।

model = get_compiled_model()
model.fit(x_train, y_train, batch_size=64, validation_split=0.2, epochs=1)
625/625 [==============================] - 2s 3ms/step - loss: 0.3682 - sparse_categorical_accuracy: 0.8957 - val_loss: 0.2276 - val_sparse_categorical_accuracy: 0.9301
<keras.callbacks.History at 0x7ff81c680890>

tf.data ডেটাসেট থেকে প্রশিক্ষণ ও মূল্যায়ন

গত কয়েক অনুচ্ছেদ, আপনি দেখা করেছি কিভাবে লোকসান, মান, এবং optimizers হ্যান্ডেল করতে, এবং আপনি দেখা করেছি কিভাবে ব্যবহার করতে validation_data এবং validation_split আর্গুমেন্ট fit() যখন আপনার ডেটা NumPy অ্যারে হিসাবে পাস করা হয়।

এখন যদি কটাক্ষপাত করা যেখানে আপনার তথ্য একটি আকারে আসে যাক tf.data.Dataset অবজেক্ট।

tf.data এপিআই একটি উপায় দ্রুত এবং মাপযোগ্য যে মধ্যে লোড জন্য TensorFlow 2.0 ইউটিলিটি এবং preprocessing ডেটার একটি সেট।

তৈরি সম্পর্কে সম্পূর্ণ নির্দেশিকা জন্য Datasets দেখুন tf.data ডকুমেন্টেশন

আপনি একটি পাস করতে পারেন Dataset উদাহরণস্বরূপ সরাসরি পদ্ধতি fit() , evaluate() , এবং predict() :

model = get_compiled_model()

# First, let's create a training Dataset instance.
# For the sake of our example, we'll use the same MNIST data as before.
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
# Shuffle and slice the dataset.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Now we get a test dataset.
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))
test_dataset = test_dataset.batch(64)

# Since the dataset already takes care of batching,
# we don't pass a `batch_size` argument.
model.fit(train_dataset, epochs=3)

# You can also evaluate or predict on a dataset.
print("Evaluate")
result = model.evaluate(test_dataset)
dict(zip(model.metrics_names, result))
Epoch 1/3
782/782 [==============================] - 2s 3ms/step - loss: 0.3372 - sparse_categorical_accuracy: 0.9047
Epoch 2/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1596 - sparse_categorical_accuracy: 0.9523
Epoch 3/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1171 - sparse_categorical_accuracy: 0.9655
Evaluate
157/157 [==============================] - 0s 2ms/step - loss: 0.1211 - sparse_categorical_accuracy: 0.9648
{'loss': 0.12107347697019577,
 'sparse_categorical_accuracy': 0.9648000001907349}

মনে রাখবেন যে ডেটাসেট প্রতিটি যুগের শেষে পুনরায় সেট করা হয়, তাই এটি পরবর্তী যুগে পুনরায় ব্যবহার করা যেতে পারে।

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

আপনি যদি এটি করেন, প্রতিটি যুগের শেষে ডেটাসেটটি পুনরায় সেট করা হয় না, পরিবর্তে আমরা কেবল পরবর্তী ব্যাচগুলি আঁকতে থাকি। ডেটাসেট শেষ পর্যন্ত ডেটা শেষ হয়ে যাবে (যদি না এটি একটি অসীম-লুপিং ডেটাসেট হয়)।

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Only use the 100 batches per epoch (that's 64 * 100 samples)
model.fit(train_dataset, epochs=3, steps_per_epoch=100)
Epoch 1/3
100/100 [==============================] - 1s 3ms/step - loss: 0.7937 - sparse_categorical_accuracy: 0.7894
Epoch 2/3
100/100 [==============================] - 0s 3ms/step - loss: 0.3699 - sparse_categorical_accuracy: 0.8938
Epoch 3/3
100/100 [==============================] - 0s 3ms/step - loss: 0.3155 - sparse_categorical_accuracy: 0.9061
<keras.callbacks.History at 0x7ff81c587e90>

একটি বৈধতা ডেটাসেট ব্যবহার করে

আপনি একটি পাস করতে পারেন Dataset যেমন উদাহরণ হিসেবে বলা যায় validation_data মধ্যে যুক্তি fit() :

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Prepare the validation dataset
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)

model.fit(train_dataset, epochs=1, validation_data=val_dataset)
782/782 [==============================] - 3s 3ms/step - loss: 0.3380 - sparse_categorical_accuracy: 0.9035 - val_loss: 0.2015 - val_sparse_categorical_accuracy: 0.9405
<keras.callbacks.History at 0x7ff81c30e450>

প্রতিটি যুগের শেষে, মডেলটি বৈধতা ডেটাসেটের উপর পুনরাবৃত্তি করবে এবং বৈধতা ক্ষতি এবং বৈধতা মেট্রিক্স গণনা করবে।

আপনি শুধুমাত্র এই ডেটা সেটটি থেকে ব্যাচ একটি নির্দিষ্ট সংখ্যার উপর বৈধতা চালাতে চান, তাহলে আপনি পাস করতে পারেন validation_steps যুক্তি, যা নির্দিষ্ট করে কত বৈধতা মডেল বৈধতা বিঘ্নিত এবং পরবর্তী যুগে যাওয়ার আগে বৈধতা ডেটা সেটটি সঙ্গে চালানো উচিত ধাপ:

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Prepare the validation dataset
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)

model.fit(
    train_dataset,
    epochs=1,
    # Only run validation using the first 10 batches of the dataset
    # using the `validation_steps` argument
    validation_data=val_dataset,
    validation_steps=10,
)
782/782 [==============================] - 3s 3ms/step - loss: 0.3369 - sparse_categorical_accuracy: 0.9036 - val_loss: 0.2953 - val_sparse_categorical_accuracy: 0.9187
<keras.callbacks.History at 0x7ff81c30e310>

নোট করুন যে বৈধকরণ ডেটাসেট প্রতিটি ব্যবহারের পরে পুনরায় সেট করা হবে (যাতে আপনি সর্বদা একই নমুনাগুলি থেকে যুগ থেকে যুগে মূল্যায়ন করবেন)।

যুক্তি validation_split (প্রশিক্ষণ তথ্য থেকে একটি holdout সেট উৎপাদিত) সমর্থিত নয় যখন থেকে প্রশিক্ষণ Dataset বস্তু, যেহেতু এই বৈশিষ্ট্যটি সূচক ক্ষমতা ডেটাসেট নমুনা, যা দিয়ে সাধারণভাবে সম্ভব নয় প্রয়োজন Dataset API- টি।

অন্যান্য ইনপুট ফরম্যাট সমর্থিত

NumPy অ্যারে, উৎসুক tensors এবং TensorFlow এছাড়া Datasets , এটা পান্ডাস dataframes ব্যবহার করে একটি Keras মডেল প্রশিক্ষণের সম্ভব, অথবা পাইথন জেনারেটর থেকে যে ডেটা & লেবেলের ফলন ব্যাচ।

বিশেষ করে, keras.utils.Sequence বর্গ অফার একটি সহজ ইন্টারফেস পাইথন তথ্য জেনারেটর যে মাল্টিপ্রসেসিং-সচেতন হয় এবং এলোমেলো করা যাবে নির্মান করে।

সাধারণভাবে, আমরা আপনাকে ব্যবহার করার পরামর্শ দিই:

  • আপনার ডেটা ছোট হলে এবং মেমরিতে ফিট হলে NumPy ইনপুট ডেটা
  • Dataset বস্তু যদি বৃহৎ ডেটাসেট আছে এবং আপনি বিতরণ প্রশিক্ষণ যা করতে হবে
  • Sequence বস্তু যদি বৃহৎ ডেটাসেট আছে এবং আপনি যে TensorFlow মধ্যে সম্পন্ন করা যাবে না (যেমন যদি আপনি ডাটা লোড করা হচ্ছে অথবা preprocessing জন্য বহিরাগত লাইব্রেরি উপর নির্ভর) কাস্টম পাইথন প্রান্তের প্রক্রিয়াকরণ অনেক কাজ করতে হবে।

একটি ব্যবহার keras.utils.Sequence ইনপুট হিসাবে বস্তুর

keras.utils.Sequence একটি ইউটিলিটি আপনি দুটি গুরুত্বপূর্ণ বৈশিষ্ট্য সঙ্গে একটি পাইথন জেনারেটরের প্রাপ্ত উপশ্রেণী নিয়েছি:

  • এটি মাল্টিপ্রসেসিংয়ের সাথে ভাল কাজ করে।
  • এটা তোলে এলোমেলো করা যাবে (যেমন যখন পাশ করার shuffle=True মধ্যে fit() )।

একটি Sequence দুটি পদ্ধতি বাস্তবায়ন করতে হবে:

  • __getitem__
  • __len__

পদ্ধতি __getitem__ সম্পূর্ণ ব্যাচ ফেরত পাঠাবেন। আপনি সময়কাল মধ্যে আপনার ডেটা সেটটি পরিবর্তন করতে চান, আপনি বাস্তবায়ন করিতে পারিবে on_epoch_end

এখানে একটি দ্রুত উদাহরণ:

from skimage.io import imread
from skimage.transform import resize
import numpy as np

# Here, `filenames` is list of path to the images
# and `labels` are the associated labels.

class CIFAR10Sequence(Sequence):
    def __init__(self, filenames, labels, batch_size):
        self.filenames, self.labels = filenames, labels
        self.batch_size = batch_size

    def __len__(self):
        return int(np.ceil(len(self.filenames) / float(self.batch_size)))

    def __getitem__(self, idx):
        batch_x = self.filenames[idx * self.batch_size:(idx + 1) * self.batch_size]
        batch_y = self.labels[idx * self.batch_size:(idx + 1) * self.batch_size]
        return np.array([
            resize(imread(filename), (200, 200))
               for filename in batch_x]), np.array(batch_y)

sequence = CIFAR10Sequence(filenames, labels, batch_size)
model.fit(sequence, epochs=10)

নমুনা ওজন এবং শ্রেণী ওজন ব্যবহার করে

ডিফল্ট সেটিংসের সাথে একটি নমুনার ওজন ডেটাসেটের ফ্রিকোয়েন্সি দ্বারা নির্ধারিত হয়। নমুনা ফ্রিকোয়েন্সি থেকে স্বাধীনভাবে ডেটা ওজন করার দুটি পদ্ধতি রয়েছে:

  • শ্রেণীর ওজন
  • নমুনা ওজন

শ্রেণীর ওজন

এই একটি অভিধান ক্ষণস্থায়ী দ্বারা সেট করা হয় class_weight আর্গুমেন্ট প্রাপ্ত করতে Model.fit() এই অভিধানটি এই শ্রেণীর নমুনাগুলির জন্য যে ওজন ব্যবহার করা উচিত তার সাথে শ্রেণী সূচকগুলিকে মানচিত্র করে।

এটি পুনরায় নমুনা ছাড়াই ক্লাসের ভারসাম্য বজায় রাখতে বা একটি নির্দিষ্ট শ্রেণিকে বেশি গুরুত্ব দেয় এমন একটি মডেলকে প্রশিক্ষণ দিতে ব্যবহার করা যেতে পারে।

উদাহরণস্বরূপ, যদি আপনার বর্গ "0" হিসাবে শ্রেণী "1" আপনার ডেটা হিসেবে প্রতিনিধিত্ব অর্ধেক হয়, তাহলে আপনি ব্যবহার করতে পারে Model.fit(..., class_weight={0: 1., 1: 0.5})

এখানে একটি NumPy উদাহরণ দেওয়া হল যেখানে আমরা ক্লাস #5 এর সঠিক শ্রেণীবিভাগকে আরও গুরুত্ব দিতে শ্রেণী ওজন বা নমুনা ওজন ব্যবহার করি (যা MNIST ডেটাসেটে "5" সংখ্যা)।

import numpy as np

class_weight = {
    0: 1.0,
    1: 1.0,
    2: 1.0,
    3: 1.0,
    4: 1.0,
    # Set weight "2" for class "5",
    # making this class 2x more important
    5: 2.0,
    6: 1.0,
    7: 1.0,
    8: 1.0,
    9: 1.0,
}

print("Fit with class weight")
model = get_compiled_model()
model.fit(x_train, y_train, class_weight=class_weight, batch_size=64, epochs=1)
Fit with class weight
782/782 [==============================] - 2s 3ms/step - loss: 0.3708 - sparse_categorical_accuracy: 0.9032
<keras.callbacks.History at 0x7ff80c7ddd10>

নমুনা ওজন

সূক্ষ্ম দানাদার নিয়ন্ত্রণের জন্য, অথবা যদি আপনি একটি শ্রেণীবিভাগ তৈরি না করেন, আপনি "নমুনা ওজন" ব্যবহার করতে পারেন।

  • যখন NumPy তথ্য থেকে প্রশিক্ষণ: পাস sample_weight আর্গুমেন্ট প্রাপ্ত করতে Model.fit()
  • যখন থেকে প্রশিক্ষণ tf.data বা পুনরুক্তিকারীর অন্য কোন করুনঃ: ইল্ড (input_batch, label_batch, sample_weight_batch) tuples।

একটি "নমুনা ওজন" অ্যারে সংখ্যাগুলির একটি অ্যারে যা নির্দিষ্ট করে যে একটি ব্যাচের প্রতিটি নমুনার মোট ক্ষতি গণনা করার জন্য কত ওজন থাকা উচিত। এটি সাধারণত ভারসাম্যহীন শ্রেণীবিভাগের সমস্যায় ব্যবহৃত হয় (কদাচিৎ দেখা ক্লাসে আরও ওজন দেওয়ার ধারণা)।

ব্যবহৃত ওজন বেশী এবং zeros হয়, অ্যারে ক্ষতি ফাংশন (সম্পূর্ণরূপে মোট ক্ষতি নির্দিষ্ট নমুনা অবদান খারিজ) জন্য একটি মাস্ক হিসেবে ব্যবহার করা যেতে পারে।

sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.0

print("Fit with sample weight")
model = get_compiled_model()
model.fit(x_train, y_train, sample_weight=sample_weight, batch_size=64, epochs=1)
Fit with sample weight
782/782 [==============================] - 2s 3ms/step - loss: 0.3806 - sparse_categorical_accuracy: 0.9000
<keras.callbacks.History at 0x7ff80c650350>

এখানে একটি মিলে এর Dataset উদাহরণ:

sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.0

# Create a Dataset that includes sample weights
# (3rd element in the return tuple).
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train, sample_weight))

# Shuffle and slice the dataset.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

model = get_compiled_model()
model.fit(train_dataset, epochs=1)
782/782 [==============================] - 3s 3ms/step - loss: 0.3588 - sparse_categorical_accuracy: 0.9070
<keras.callbacks.History at 0x7ff80c51cb50>

মাল্টি-ইনপুট, মাল্টি-আউটপুট মডেলগুলিতে ডেটা পাস করা

পূর্ববর্তী উদাহরণ, আমরা একটি একক ইনপুট (আকৃতি একটি টেন্সর সঙ্গে একটি মডেল বিবেচনা করা হয় (764,) ) এবং একটি একক আউটপুট (আকৃতি একটি পূর্বানুমান টেন্সর (10,) )। কিন্তু একাধিক ইনপুট বা আউটপুট আছে যে মডেল সম্পর্কে কি?

নিম্নলিখিত মডেল, যা আকৃতি একটি চিত্র ইনপুট হয়েছে বিবেচনা করুন (32, 32, 3) (যে এর (height, width, channels) ) এবং আকৃতি একটি সময় সিরিজ ইনপুট (None, 10) (যে এর (timesteps, features) )। আমাদের মডেল দুটি আউটপুট এই ইনপুট সমাহার থেকে নির্ণিত হবে: একটি "স্কোর" (আকৃতি (1,) ) এবং একটি সম্ভাব্যতা (আকৃতি পাঁচটি শ্রেণীর উপর বন্টন (5,) )।

image_input = keras.Input(shape=(32, 32, 3), name="img_input")
timeseries_input = keras.Input(shape=(None, 10), name="ts_input")

x1 = layers.Conv2D(3, 3)(image_input)
x1 = layers.GlobalMaxPooling2D()(x1)

x2 = layers.Conv1D(3, 3)(timeseries_input)
x2 = layers.GlobalMaxPooling1D()(x2)

x = layers.concatenate([x1, x2])

score_output = layers.Dense(1, name="score_output")(x)
class_output = layers.Dense(5, name="class_output")(x)

model = keras.Model(
    inputs=[image_input, timeseries_input], outputs=[score_output, class_output]
)

আসুন এই মডেলটি প্লট করি, যাতে আপনি স্পষ্টভাবে দেখতে পারেন যে আমরা এখানে কী করছি (মনে রাখবেন যে প্লটে দেখানো আকারগুলি প্রতি-নমুনা আকারের পরিবর্তে ব্যাচের আকার)।

keras.utils.plot_model(model, "multi_input_and_output_model.png", show_shapes=True)

png

সংকলনের সময়, আমরা একটি তালিকা হিসাবে ক্ষতি ফাংশন পাস করে বিভিন্ন আউটপুটে বিভিন্ন ক্ষতি নির্দিষ্ট করতে পারি:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
)

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

একইভাবে মেট্রিক্সের জন্য:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
    metrics=[
        [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        [keras.metrics.CategoricalAccuracy()],
    ],
)

যেহেতু আমরা আমাদের আউটপুট স্তরগুলির নাম দিয়েছি, তাই আমরা প্রতি-আউটপুট ক্ষয়ক্ষতি এবং মেট্রিক্স একটি ডিক্টের মাধ্যমেও নির্দিষ্ট করতে পারি:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={
        "score_output": keras.losses.MeanSquaredError(),
        "class_output": keras.losses.CategoricalCrossentropy(),
    },
    metrics={
        "score_output": [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        "class_output": [keras.metrics.CategoricalAccuracy()],
    },
)

আপনার কাছে 2টির বেশি আউটপুট থাকলে আমরা স্পষ্ট নাম এবং নির্দেশাবলী ব্যবহার করার পরামর্শ দিই।

এটি বিভিন্ন আউটপুট-নির্দিষ্ট লোকসান বিভিন্ন ওজন দিতে (উদাহরণস্বরূপ, এক, আমাদের উদাহরণে "স্কোর" ক্ষতি বিশেষাধিকার করতে ইচ্ছুক পারে বর্গ ক্ষতির গুরুত্ব 2x দেওয়ার দ্বারা) ব্যবহার করে, সম্ভব loss_weights যুক্তি:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={
        "score_output": keras.losses.MeanSquaredError(),
        "class_output": keras.losses.CategoricalCrossentropy(),
    },
    metrics={
        "score_output": [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        "class_output": [keras.metrics.CategoricalAccuracy()],
    },
    loss_weights={"score_output": 2.0, "class_output": 1.0},
)

আপনি নির্দিষ্ট আউটপুটগুলির জন্য ক্ষতি গণনা না করাও বেছে নিতে পারেন, যদি এই আউটপুটগুলি পূর্বাভাসের জন্য হয় তবে প্রশিক্ষণের জন্য নয়:

# List loss version
model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[None, keras.losses.CategoricalCrossentropy()],
)

# Or dict loss version
model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={"class_output": keras.losses.CategoricalCrossentropy()},
)

একটি মাল্টি-ইনপুট বা মাল্টি আউটপুট মডেল ডেটা পাসিং fit() কম্পাইল মধ্যে একটি ক্ষতি ফাংশন উল্লেখ হিসাবে একই ভাবে কাজ করে: আউটপুট যে একটি ক্ষতি ফাংশন পেয়েছেন 1 ম্যাপিং: আপনি 1 NumPy অ্যারে তালিকা (পাস করতে পারেন ) অথবা NumPy অ্যারে আউটপুট নাম ম্যাপিং dicts।

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
)

# Generate dummy NumPy data
img_data = np.random.random_sample(size=(100, 32, 32, 3))
ts_data = np.random.random_sample(size=(100, 20, 10))
score_targets = np.random.random_sample(size=(100, 1))
class_targets = np.random.random_sample(size=(100, 5))

# Fit on lists
model.fit([img_data, ts_data], [score_targets, class_targets], batch_size=32, epochs=1)

# Alternatively, fit on dicts
model.fit(
    {"img_input": img_data, "ts_input": ts_data},
    {"score_output": score_targets, "class_output": class_targets},
    batch_size=32,
    epochs=1,
)
4/4 [==============================] - 2s 9ms/step - loss: 5.6917 - score_output_loss: 0.1031 - class_output_loss: 5.5886
4/4 [==============================] - 0s 6ms/step - loss: 4.4108 - score_output_loss: 0.0999 - class_output_loss: 4.3109
<keras.callbacks.History at 0x7ff80c3b4110>

এখানে Dataset ব্যবহার কেস: একভাবে যেমন আমরা কি NumPy অ্যারে জন্য করেছিলাম, Dataset dicts একটি tuple ফেরত পাঠাবেন।

train_dataset = tf.data.Dataset.from_tensor_slices(
    (
        {"img_input": img_data, "ts_input": ts_data},
        {"score_output": score_targets, "class_output": class_targets},
    )
)
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

model.fit(train_dataset, epochs=1)
2/2 [==============================] - 0s 21ms/step - loss: 4.2451 - score_output_loss: 0.0993 - class_output_loss: 4.1458
<keras.callbacks.History at 0x7ff80c3ed450>

কলব্যাক ব্যবহার করে

কেরাসে কলব্যাকগুলি এমন বস্তু যা প্রশিক্ষণের সময় বিভিন্ন পয়েন্টে ডাকা হয় (একটি যুগের শুরুতে, একটি ব্যাচের শেষে, একটি যুগের শেষে, ইত্যাদি)। তারা নির্দিষ্ট আচরণ বাস্তবায়ন করতে ব্যবহার করা যেতে পারে, যেমন:

  • প্রশিক্ষণের সময় বিভিন্ন পয়েন্টে বৈধকরণ করা (বিল্ট-ইন প্রতি যুগের বৈধতার বাইরে)
  • নিয়মিত বিরতিতে মডেলটিকে চেকপয়েন্ট করা বা যখন এটি একটি নির্দিষ্ট নির্ভুলতা থ্রেশহোল্ড অতিক্রম করে
  • মডেল শেখার হার পরিবর্তন যখন প্রশিক্ষণ plateauing বলে মনে হয়
  • প্রশিক্ষণ যখন মালভূমি বলে মনে হয় তখন উপরের স্তরগুলির ফাইন-টিউনিং করা
  • ইমেল বা তাত্ক্ষণিক বার্তা বিজ্ঞপ্তি পাঠানো যখন প্রশিক্ষণ শেষ হয় বা যেখানে একটি নির্দিষ্ট কর্মক্ষমতা থ্রেশহোল্ড অতিক্রম করা হয়
  • ইত্যাদি।

Callbacks আপনার কলে একটি তালিকা হিসাবে প্রেরণ করা সম্ভব fit() :

model = get_compiled_model()

callbacks = [
    keras.callbacks.EarlyStopping(
        # Stop training when `val_loss` is no longer improving
        monitor="val_loss",
        # "no longer improving" being defined as "no better than 1e-2 less"
        min_delta=1e-2,
        # "no longer improving" being further defined as "for at least 2 epochs"
        patience=2,
        verbose=1,
    )
]
model.fit(
    x_train,
    y_train,
    epochs=20,
    batch_size=64,
    callbacks=callbacks,
    validation_split=0.2,
)
Epoch 1/20
625/625 [==============================] - 2s 3ms/step - loss: 0.3725 - sparse_categorical_accuracy: 0.8939 - val_loss: 0.2314 - val_sparse_categorical_accuracy: 0.9321
Epoch 2/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1805 - sparse_categorical_accuracy: 0.9471 - val_loss: 0.2012 - val_sparse_categorical_accuracy: 0.9379
Epoch 3/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1346 - sparse_categorical_accuracy: 0.9603 - val_loss: 0.1651 - val_sparse_categorical_accuracy: 0.9505
Epoch 4/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1065 - sparse_categorical_accuracy: 0.9684 - val_loss: 0.1510 - val_sparse_categorical_accuracy: 0.9571
Epoch 5/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0884 - sparse_categorical_accuracy: 0.9734 - val_loss: 0.1505 - val_sparse_categorical_accuracy: 0.9538
Epoch 6/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0746 - sparse_categorical_accuracy: 0.9778 - val_loss: 0.1508 - val_sparse_categorical_accuracy: 0.9575
Epoch 00006: early stopping
<keras.callbacks.History at 0x7ff80c64cad0>

অনেক বিল্ট-ইন কলব্যাক উপলব্ধ

কেরাসে ইতিমধ্যেই অনেক বিল্ট-ইন কলব্যাক উপলব্ধ রয়েছে, যেমন:

  • ModelCheckpoint : পর্যায়ক্রমে মডেল সংরক্ষণ করুন।
  • EarlyStopping : স্টপ প্রশিক্ষণ যখন প্রশিক্ষণ বৈধতা মেট্রিক্স উন্নতি এখন আর নেই।
  • TensorBoard : পর্যায়ক্রমে লেখার মডেল লগ যে ভিজ্যুয়ালাইজ করা যেতে পারে TensorBoard (অধ্যায় "ভিজুয়ালাইজেশান" এ আরো বিস্তারিত জানার)।
  • CSVLogger : একটি CSV ফাইলে কমে যাওয়া এবং বৈশিষ্ট্যের মান ডেটা স্রোত বইবে।
  • ইত্যাদি

দেখুন callbacks ডকুমেন্টেশন সম্পূর্ণ তালিকার জন্য।

আপনার নিজের কলব্যাক লেখা

আপনি বেস বর্গ ব্যাপ্ত দ্বারা একটি কাস্টম কলব্যাক তৈরি করতে পারেন keras.callbacks.Callback । একটি কলব্যাক বর্গ সম্পত্তি মাধ্যমে এর সংশ্লিষ্ট মডেল অ্যাক্সেস আছে self.model

পড়া নিশ্চিত করা কাস্টম callbacks লেখা সম্পূর্ণ নির্দেশিকা

এখানে প্রশিক্ষণের সময় প্রতি-ব্যাচ ক্ষতির মানগুলির একটি তালিকা সংরক্ষণ করার একটি সাধারণ উদাহরণ রয়েছে:

class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs):
        self.per_batch_losses = []

    def on_batch_end(self, batch, logs):
        self.per_batch_losses.append(logs.get("loss"))

চেকপয়েন্টিং মডেল

আপনি যখন তুলনামূলকভাবে বড় ডেটাসেটের মডেল প্রশিক্ষণ দিচ্ছেন, তখন ঘন ঘন বিরতিতে আপনার মডেলের চেকপয়েন্ট সংরক্ষণ করা অত্যন্ত গুরুত্বপূর্ণ।

সবচেয়ে সহজ উপায় এই অর্জন করার সাথে আছেন ModelCheckpoint কলব্যাক:

model = get_compiled_model()

callbacks = [
    keras.callbacks.ModelCheckpoint(
        # Path where to save the model
        # The two parameters below mean that we will overwrite
        # the current checkpoint if and only if
        # the `val_loss` score has improved.
        # The saved model name will include the current epoch.
        filepath="mymodel_{epoch}",
        save_best_only=True,  # Only save a model if `val_loss` has improved.
        monitor="val_loss",
        verbose=1,
    )
]
model.fit(
    x_train, y_train, epochs=2, batch_size=64, callbacks=callbacks, validation_split=0.2
)
Epoch 1/2
613/625 [============================>.] - ETA: 0s - loss: 0.3693 - sparse_categorical_accuracy: 0.8972
Epoch 00001: val_loss improved from inf to 0.23508, saving model to mymodel_1
2021-11-12 20:11:50.182298: 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.
INFO:tensorflow:Assets written to: mymodel_1/assets
625/625 [==============================] - 3s 4ms/step - loss: 0.3660 - sparse_categorical_accuracy: 0.8979 - val_loss: 0.2351 - val_sparse_categorical_accuracy: 0.9273
Epoch 2/2
620/625 [============================>.] - ETA: 0s - loss: 0.1659 - sparse_categorical_accuracy: 0.9507
Epoch 00002: val_loss improved from 0.23508 to 0.16898, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets
625/625 [==============================] - 2s 3ms/step - loss: 0.1657 - sparse_categorical_accuracy: 0.9507 - val_loss: 0.1690 - val_sparse_categorical_accuracy: 0.9482
<keras.callbacks.History at 0x7ff8b577cc90>

ModelCheckpoint কলব্যাক দোষ সহনশীলতা প্রয়োগ করতে ব্যবহৃত করা যেতে পারে: কেস প্রশিক্ষণ মডেল সর্বশেষ সংরক্ষিত রাষ্ট্র থেকে পুনর্সূচনা প্রশিক্ষণ করার ক্ষমতা এলোমেলোভাবে বিঘ্নিত হয়। এখানে একটি মৌলিক উদাহরণ:

import os

# Prepare a directory to store all the checkpoints.
checkpoint_dir = "./ckpt"
if not os.path.exists(checkpoint_dir):
    os.makedirs(checkpoint_dir)


def make_or_restore_model():
    # Either restore the latest model, or create a fresh one
    # if there is no checkpoint available.
    checkpoints = [checkpoint_dir + "/" + name for name in os.listdir(checkpoint_dir)]
    if checkpoints:
        latest_checkpoint = max(checkpoints, key=os.path.getctime)
        print("Restoring from", latest_checkpoint)
        return keras.models.load_model(latest_checkpoint)
    print("Creating a new model")
    return get_compiled_model()


model = make_or_restore_model()
callbacks = [
    # This callback saves a SavedModel every 100 batches.
    # We include the training loss in the saved model name.
    keras.callbacks.ModelCheckpoint(
        filepath=checkpoint_dir + "/ckpt-loss={loss:.2f}", save_freq=100
    )
]
model.fit(x_train, y_train, epochs=1, callbacks=callbacks)
Creating a new model
  88/1563 [>.............................] - ETA: 3s - loss: 1.1203 - sparse_categorical_accuracy: 0.6911INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=1.04/assets
 185/1563 [==>...........................] - ETA: 6s - loss: 0.7768 - sparse_categorical_accuracy: 0.7858INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.75/assets
 286/1563 [====>.........................] - ETA: 6s - loss: 0.6382 - sparse_categorical_accuracy: 0.8211INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.63/assets
 383/1563 [======>.......................] - ETA: 6s - loss: 0.5584 - sparse_categorical_accuracy: 0.8433INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.55/assets
 484/1563 [========>.....................] - ETA: 6s - loss: 0.5032 - sparse_categorical_accuracy: 0.8578INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.50/assets
 586/1563 [==========>...................] - ETA: 5s - loss: 0.4644 - sparse_categorical_accuracy: 0.8684INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.46/assets
 685/1563 [============>.................] - ETA: 5s - loss: 0.4356 - sparse_categorical_accuracy: 0.8762INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.43/assets
 783/1563 [==============>...............] - ETA: 5s - loss: 0.4127 - sparse_categorical_accuracy: 0.8825INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.41/assets
 883/1563 [===============>..............] - ETA: 4s - loss: 0.3958 - sparse_categorical_accuracy: 0.8868INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.39/assets
 985/1563 [=================>............] - ETA: 3s - loss: 0.3766 - sparse_categorical_accuracy: 0.8918INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.38/assets
1086/1563 [===================>..........] - ETA: 3s - loss: 0.3624 - sparse_categorical_accuracy: 0.8958INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.36/assets
1184/1563 [=====================>........] - ETA: 2s - loss: 0.3498 - sparse_categorical_accuracy: 0.8994INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.35/assets
1283/1563 [=======================>......] - ETA: 1s - loss: 0.3383 - sparse_categorical_accuracy: 0.9029INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1386/1563 [=========================>....] - ETA: 1s - loss: 0.3265 - sparse_categorical_accuracy: 0.9058INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1485/1563 [===========================>..] - ETA: 0s - loss: 0.3184 - sparse_categorical_accuracy: 0.9081INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1563/1563 [==============================] - 11s 7ms/step - loss: 0.3122 - sparse_categorical_accuracy: 0.9097
<keras.callbacks.History at 0x7ff8b53e1dd0>

মডেল সংরক্ষণ এবং পুনরুদ্ধারের জন্য আপনি কল করুন আপনার নিজস্ব কলব্যাক লিখুন।

ধারাবাহিকতাতে এবং সংরক্ষণ করা একটি সম্পূর্ণ নির্দেশিকা জন্য, দেখুন সংরক্ষণ এবং মডেল serializing গাইড

শেখার হার সময়সূচী ব্যবহার করে

গভীর শিক্ষার মডেলগুলিকে প্রশিক্ষণ দেওয়ার সময় একটি সাধারণ প্যাটার্ন হল প্রশিক্ষণের অগ্রগতির সাথে ধীরে ধীরে শেখার হ্রাস করা। এটি সাধারণত "শিক্ষার হার ক্ষয়" নামে পরিচিত।

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

একটি অপ্টিমাইজার একটি সময়সূচী পাস

আপনি সহজেই যেমন একটি সময়সূচী বস্তুর পাশ দিয়ে একটি স্ট্যাটিক শেখার হার ক্ষয় সময়তালিকা ব্যবহার করতে পারেন learning_rate আপনার অপটিমাইজার মধ্যে যুক্তি:

initial_learning_rate = 0.1
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate, decay_steps=100000, decay_rate=0.96, staircase=True
)

optimizer = keras.optimizers.RMSprop(learning_rate=lr_schedule)

বেশ কিছু বিল্ট-ইন সময়সূচী পাওয়া যায়: ExponentialDecay , PiecewiseConstantDecay , PolynomialDecay এবং InverseTimeDecay

একটি গতিশীল শেখার হার সময়সূচী বাস্তবায়ন করতে কলব্যাক ব্যবহার করে

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

যাইহোক, কলব্যাকগুলির বৈধতা মেট্রিক্স সহ সমস্ত মেট্রিক্সে অ্যাক্সেস রয়েছে! এইভাবে আপনি একটি কলব্যাক ব্যবহার করে এই প্যাটার্নটি অর্জন করতে পারেন যা অপ্টিমাইজারে বর্তমান শেখার হার পরিবর্তন করে। বস্তুত, এই এমনকি বিল্ট-ইন হিসেবে ReduceLROnPlateau কলব্যাক।

প্রশিক্ষণের সময় ক্ষতি এবং মেট্রিক্স ভিজ্যুয়ালাইজ করা

সবচেয়ে ভালো উপায় প্রশিক্ষণের সময় আপনার মডেল উপর নজর রাখার ব্যবহার করা TensorBoard - একটি ব্রাউজার-ভিত্তিক অ্যাপ্লিকেশন যা আপনাকে স্থানীয়ভাবে চালাতে পারেন যে অবশ্যই থাকবেঃ

  • প্রশিক্ষণ এবং মূল্যায়নের জন্য ক্ষতির লাইভ প্লট এবং মেট্রিক্স
  • (ঐচ্ছিকভাবে) আপনার লেয়ার অ্যাক্টিভেশনের হিস্টোগ্রামের ভিজ্যুয়ালাইজেশন
  • (ঐচ্ছিকভাবে) এম্বেডিং স্পেস 3D দৃশ্য আপনার দ্বারা শিখেছি Embedding স্তর

আপনি যদি পিপ দিয়ে টেনসরফ্লো ইনস্টল করে থাকেন, তাহলে কমান্ড লাইন থেকে টেনসরবোর্ড চালু করতে পারবেন:

tensorboard --logdir=/full_path_to_your_logs

TensorBoard কলব্যাক ব্যবহার করে

সবচেয়ে সহজ উপায় একটি Keras মডেল এবং সঙ্গে TensorBoard ব্যবহার করতে fit() পদ্ধতি TensorBoard কলব্যাক।

সবচেয়ে সহজ ক্ষেত্রে, আপনি কলব্যাকটি কোথায় লগ লিখতে চান তা নির্দিষ্ট করুন এবং আপনি যেতে পারবেন:

keras.callbacks.TensorBoard(
    log_dir="/full_path_to_your_logs",
    histogram_freq=0,  # How often to log histogram visualizations
    embeddings_freq=0,  # How often to log embedding visualizations
    update_freq="epoch",
)  # How often to write logs (default: once per epoch)
<keras.callbacks.TensorBoard at 0x7ff88c8c04d0>

আরো তথ্যের জন্য, দেখুন ডকুমেন্টেশন TensorBoard কলব্যাক