তারিখটা মনে রেখো! গুগল I / O মে 18-20 মে এখনই রেজিস্টার করুন
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

ভূমিকা

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

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

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

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

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

এপিআই ওভারভিউ: প্রথম প্রান্ত থেকে শেষের উদাহরণ

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

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

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)

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

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

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

(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]

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

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

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.5769 - sparse_categorical_accuracy: 0.8386 - val_loss: 0.1833 - val_sparse_categorical_accuracy: 0.9464
Epoch 2/2
782/782 [==============================] - 2s 2ms/step - loss: 0.1621 - sparse_categorical_accuracy: 0.9518 - val_loss: 0.1467 - val_sparse_categorical_accuracy: 0.9579

ফিরে আসা history অবজেক্টটি প্রশিক্ষণের সময় লোকসানের মান এবং মেট্রিক মানগুলির রেকর্ড ধারণ করে:

history.history

{'loss': [0.3323673903942108, 0.15159013867378235],
 'sparse_categorical_accuracy': [0.9050800204277039, 0.9542400240898132],
 'val_loss': [0.18328842520713806, 0.14667865633964539],
 'val_sparse_categorical_accuracy': [0.946399986743927, 0.9578999876976013]}

আমরা মূল্যায়নের মাধ্যমে পরীক্ষার তথ্যগুলিতে মডেলটি 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.1449 - sparse_categorical_accuracy: 0.9539
test loss, test acc: [0.14493884146213531, 0.9538999795913696]
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"],
)

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

02d9fi830

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

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

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

  • 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 [==============================] - 1s 1ms/step - loss: 0.0272
<tensorflow.python.keras.callbacks.History at 0x7fb6b01c09e8>

যদি আপনার কোনও ক্ষতির ফাংশন প্রয়োজন হয় যা 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.0489
<tensorflow.python.keras.callbacks.History at 0x7fb6b00725f8>

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

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

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

রাষ্ট্রীয় আপডেট এবং ফলাফলের গণনা যথাক্রমে পৃথকভাবে রাখা হয় ( 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_states(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 2ms/step - loss: 0.5782 - categorical_true_positives: 22110.9323
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1737 - categorical_true_positives: 23825.8212
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1254 - categorical_true_positives: 24152.4547
<tensorflow.python.keras.callbacks.History at 0x7fb6a42a55f8>

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

অপ্রতিরোধ্য ক্ষতির পরিমাণ এবং মেট্রিকগুলি 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: 3.4140
<tensorflow.python.keras.callbacks.History at 0x7fb6a4233748>

আপনি 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.5646 - std_of_activation: 0.9702
<tensorflow.python.keras.callbacks.History at 0x7fb6a40cf6a0>

ফাংশনাল model.add_loss(loss_tensor) , আপনি 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 2ms/step - loss: 3.6195 - std_of_activation: 0.0020
<tensorflow.python.keras.callbacks.History at 0x7fb6a07d42b0>

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

নিম্নলিখিত LogisticEndpoint ইন্ডপয়েন্ট স্তরটি বিবেচনা করুন: এটি ইনপুট লক্ষ্য এবং লগইট হিসাবে গ্রহণ করে এবং এটি add_loss() মাধ্যমে 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 222ms/step - loss: 0.9652 - binary_accuracy: 0.0000e+00
<tensorflow.python.keras.callbacks.History at 0x7fb6a05e01d0>

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

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

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

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

বৈধতাটি যেভাবে গণনা করা হয় তা হ'ল কোনও পরিবর্তন করার আগে fit() কল দ্বারা প্রাপ্ত অ্যারের শেষ x% নমুনা নেওয়া।

মনে রাখবেন আপনি শুধুমাত্র ব্যবহার করতে পারেন 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 2ms/step - loss: 0.6075 - sparse_categorical_accuracy: 0.8389 - val_loss: 0.2291 - val_sparse_categorical_accuracy: 0.9322
<tensorflow.python.keras.callbacks.History at 0x7fb6a0504240>

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

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

আসুন এখন সেই মামলার দিকে একবার নজর দিন যেখানে আপনার ডেটা একটিtf.data.Dataset অবজেক্টের আকারে আসে।

tf.data এপিআই হ'ল দ্রুত এবং স্কেলযোগ্য এমন উপায়ে ডেটা লোড এবং tf.data জন্য tf.data ২.০ এর ইউটিলিটির একটি সেট।

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

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

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 2ms/step - loss: 0.5652 - sparse_categorical_accuracy: 0.8404
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1721 - sparse_categorical_accuracy: 0.9497
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1170 - sparse_categorical_accuracy: 0.9645
Evaluate
157/157 [==============================] - 0s 2ms/step - loss: 0.1308 - sparse_categorical_accuracy: 0.9602
{'loss': 0.13075917959213257,
 'sparse_categorical_accuracy': 0.9602000117301941}

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

আপনি যদি এই ডেটাসেট থেকে কেবলমাত্র নির্দিষ্ট সংখ্যক ব্যাচের উপর প্রশিক্ষণ চালাতে চান তবে আপনি 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 2ms/step - loss: 1.2664 - sparse_categorical_accuracy: 0.6389
Epoch 2/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3868 - sparse_categorical_accuracy: 0.8875
Epoch 3/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3578 - sparse_categorical_accuracy: 0.8981
<tensorflow.python.keras.callbacks.History at 0x7fb6a02a5358>

একটি বৈধতা ডেটাसेट ব্যবহার করে

আপনি একটি পাস করতে পারেন 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 [==============================] - 2s 3ms/step - loss: 0.5754 - sparse_categorical_accuracy: 0.8384 - val_loss: 0.1829 - val_sparse_categorical_accuracy: 0.9465
<tensorflow.python.keras.callbacks.History at 0x7fb6a01651d0>

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

আপনি শুধুমাত্র এই ডেটা সেটটি থেকে ব্যাচ একটি নির্দিষ্ট সংখ্যার উপর বৈধতা চালাতে চান, তাহলে আপনি পাস করতে পারেন 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 [==============================] - 2s 2ms/step - loss: 0.5503 - sparse_categorical_accuracy: 0.8507 - val_loss: 0.3296 - val_sparse_categorical_accuracy: 0.9062
<tensorflow.python.keras.callbacks.History at 0x7fb6a02e4630>

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

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

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

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

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

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

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

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

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

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

একটি Sequence অবশ্যই দুটি পদ্ধতি প্রয়োগ করতে পারে:

  • __getitem__
  • __len__

__getitem__ পদ্ধতিটি একটি সম্পূর্ণ ব্যাচ ফেরত __getitem__ উচিত। আপনি যদি আপনার on_epoch_end পর্বগুলির মধ্যে পরিবর্তন করতে চান তবে আপনি 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)

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

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

  • ক্লাস ওজন
  • নমুনা ওজন

ক্লাস ওজন

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

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

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

এখানে একটি নম্পপি উদাহরণ রয়েছে যেখানে আমরা ক্লাস # 5 এর সঠিক শ্রেণিবিন্যাসকে আরও বেশি গুরুত্ব দেওয়ার জন্য শ্রেণি ওজন বা নমুনা ওজন ব্যবহার করি (এটি এমএনআইএসটি ডেটাসেটের "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 2ms/step - loss: 0.6269 - sparse_categorical_accuracy: 0.8396
<tensorflow.python.keras.callbacks.History at 0x7fb6ca2479b0>

নমুনা ওজন

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

  • যখন sample_weight ডেটা থেকে প্রশিক্ষণ দেওয়া হয়: Model.fit() তে Model.fit() sample_weight যুক্তি পাস করুন।
  • tf.data বা অন্য কোনও ধরণের পুনরুক্তি থেকে প্রশিক্ষণ tf.data : ফলন (input_batch, label_batch, sample_weight_batch) টিপলস।

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

ব্যবহৃত ওজন বেশী এবং 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 2ms/step - loss: 0.6540 - sparse_categorical_accuracy: 0.8302
<tensorflow.python.keras.callbacks.History at 0x7fb6b03db128>

এখানে মিলে যাওয়া 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 [==============================] - 2s 2ms/step - loss: 0.6052 - sparse_categorical_accuracy: 0.8477
<tensorflow.python.keras.callbacks.History at 0x7fb6a40cc908>

মাল্টি-ইনপুট, মাল্টি-আউটপুট মডেলগুলিতে ডেটা পাঠানো

পূর্ববর্তী উদাহরণগুলিতে, আমরা একটি একক ইনপুট (আকৃতির একটি সেন্সর (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)

পিএনজি

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

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 টিরও বেশি আউটপুট থাকে তবে আমরা সুস্পষ্ট নাম এবং ডিসটিকে ব্যবহার করার পরামর্শ দিই।

loss_weights যুক্তি ব্যবহার করে, বিভিন্ন আউটপুট-নির্দিষ্ট লোকসানের ক্ষেত্রে বিভিন্ন ওজন দেওয়া সম্ভব (উদাহরণস্বরূপ, কেউ আমাদের উদাহরণে "স্কোর" ক্ষতিকে 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() -র মাল্টি-ইনপুট বা মাল্টি-আউটপুট মডেলের কাছে ডেটা পাঠানো একইভাবে কাজ করে যা সংকলনের ক্ষেত্রে ক্ষতির ফাংশন নির্দিষ্ট করে: আপনি NumPy অ্যারেগুলির তালিকা পাস করতে পারেন (ক্ষতি 1: 1 ম্যাপিংয়ের ফলে একটি ক্ষতি ফাংশন পেয়েছে) ) বা 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 [==============================] - 10s 10ms/step - loss: 12.4255 - score_output_loss: 0.7638 - class_output_loss: 11.6617
4/4 [==============================] - 0s 5ms/step - loss: 11.1176 - score_output_loss: 0.6303 - class_output_loss: 10.4873
<tensorflow.python.keras.callbacks.History at 0x7fb6a02ed828>

এখানে 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 27ms/step - loss: 10.9011 - score_output_loss: 0.4919 - class_output_loss: 10.4092
<tensorflow.python.keras.callbacks.History at 0x7fb6b00ae9e8>

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

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

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

কলব্যাকগুলি আপনার কলটিতে fit() করার জন্য একটি তালিকা হিসাবে পাস হতে পারে 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.6076 - sparse_categorical_accuracy: 0.8350 - val_loss: 0.2323 - val_sparse_categorical_accuracy: 0.9306
Epoch 2/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1925 - sparse_categorical_accuracy: 0.9436 - val_loss: 0.1828 - val_sparse_categorical_accuracy: 0.9446
Epoch 3/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1310 - sparse_categorical_accuracy: 0.9616 - val_loss: 0.1580 - val_sparse_categorical_accuracy: 0.9510
Epoch 4/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0967 - sparse_categorical_accuracy: 0.9700 - val_loss: 0.1681 - val_sparse_categorical_accuracy: 0.9490
Epoch 5/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0841 - sparse_categorical_accuracy: 0.9742 - val_loss: 0.1482 - val_sparse_categorical_accuracy: 0.9568
Epoch 00005: early stopping
<tensorflow.python.keras.callbacks.History at 0x7fb63c5945c0>

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

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

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

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

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

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

কাস্টম কলব্যাকগুলি লেখার সম্পূর্ণ গাইডটি পড়ার বিষয়টি নিশ্চিত করুন।

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

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
625/625 [==============================] - 2s 2ms/step - loss: 0.6397 - sparse_categorical_accuracy: 0.8210 - val_loss: 0.2310 - val_sparse_categorical_accuracy: 0.9326

Epoch 00001: val_loss improved from inf to 0.23098, saving model to mymodel_1
INFO:tensorflow:Assets written to: mymodel_1/assets
Epoch 2/2
625/625 [==============================] - 1s 2ms/step - loss: 0.1885 - sparse_categorical_accuracy: 0.9454 - val_loss: 0.1851 - val_sparse_categorical_accuracy: 0.9435

Epoch 00002: val_loss improved from 0.23098 to 0.18510, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets
<tensorflow.python.keras.callbacks.History at 0x7fb6a04271d0>

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
  85/1563 [>.............................] - ETA: 2s - loss: 1.4465 - sparse_categorical_accuracy: 0.5717INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.93/assets
 185/1563 [==>...........................] - ETA: 5s - loss: 1.1118 - sparse_categorical_accuracy: 0.6784INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.69/assets
 284/1563 [====>.........................] - ETA: 5s - loss: 0.9495 - sparse_categorical_accuracy: 0.7266INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.58/assets
 385/1563 [======>.......................] - ETA: 5s - loss: 0.8464 - sparse_categorical_accuracy: 0.7569INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.52/assets
 485/1563 [========>.....................] - ETA: 5s - loss: 0.7749 - sparse_categorical_accuracy: 0.7776INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.47/assets
 585/1563 [==========>...................] - ETA: 4s - loss: 0.7210 - sparse_categorical_accuracy: 0.7930INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.44/assets
 685/1563 [============>.................] - ETA: 4s - loss: 0.6788 - sparse_categorical_accuracy: 0.8050INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.42/assets
 785/1563 [==============>...............] - ETA: 4s - loss: 0.6445 - sparse_categorical_accuracy: 0.8149INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.40/assets
 883/1563 [===============>..............] - ETA: 3s - loss: 0.6165 - sparse_categorical_accuracy: 0.8229INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.38/assets
 984/1563 [=================>............] - ETA: 3s - loss: 0.5917 - sparse_categorical_accuracy: 0.8299INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.37/assets
1082/1563 [===================>..........] - ETA: 2s - loss: 0.5709 - sparse_categorical_accuracy: 0.8358INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.35/assets
1185/1563 [=====================>........] - ETA: 1s - loss: 0.5517 - sparse_categorical_accuracy: 0.8413INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1282/1563 [=======================>......] - ETA: 1s - loss: 0.5356 - sparse_categorical_accuracy: 0.8459INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1384/1563 [=========================>....] - ETA: 0s - loss: 0.5202 - sparse_categorical_accuracy: 0.8503INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1484/1563 [===========================>..] - ETA: 0s - loss: 0.5065 - sparse_categorical_accuracy: 0.8542INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.31/assets
1563/1563 [==============================] - 9s 5ms/step - loss: 0.4965 - sparse_categorical_accuracy: 0.8570
<tensorflow.python.keras.callbacks.History at 0x7fb6a036f5c0>

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

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

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

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

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

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

আপনি সহজেই যেমন একটি সময়সূচী বস্তুর পাশ দিয়ে একটি স্ট্যাটিক শেখার হার ক্ষয় সময়তালিকা ব্যবহার করতে পারেন 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 কলব্যাক হিসাবে অন্তর্নির্মিত।

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

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

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

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

tensorboard --logdir=/full_path_to_your_logs

টেনসরবোর্ড কলব্যাক ব্যবহার করা

কেরাস মডেল এবং 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)

<tensorflow.python.keras.callbacks.TensorBoard at 0x7fb6a422a748>

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