अपने स्थानीय TensorFlow के लिए RSVP आज हर जगह घटना!
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

अंतर्निहित विधियों के साथ प्रशिक्षण और मूल्यांकन

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

सेट अप

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

परिचय

यह मार्गदर्शिका प्रशिक्षण, मूल्यांकन, और भविष्यवाणी (अनुमान) मॉडल को शामिल करती है जब प्रशिक्षण और सत्यापन के लिए अंतर्निहित API का उपयोग करते हैं (जैसे कि model.fit() , model.evaluate() , model.predict() )।

यदि आप अपने स्वयं के प्रशिक्षण कदम समारोह को निर्दिष्ट करते हुए fit() लाभ उठाने में रुचि रखते हैं, तो मार्गदर्शिका " fit() में क्या होता है" को देखें ।

यदि आप स्क्रैच से अपने स्वयं के प्रशिक्षण और मूल्यांकन छोरों को लिखने में रुचि रखते हैं, तो गाइड को "स्क्रैच से एक प्रशिक्षण लूप लिखना" देखें ।

सामान्य तौर पर, चाहे आप अंतर्निहित लूप का उपयोग कर रहे हों या अपना स्वयं का लिख ​​रहे हों, मॉडल प्रशिक्षण और मूल्यांकन हर तरह के कर्स मॉडल में समान रूप से काम करता है - अनुक्रमिक मॉडल, कार्यात्मक एपीआई के साथ निर्मित मॉडल, और खरोंच से लिखे गए मॉडल मॉडल उपवर्ग।

यह गाइड वितरित प्रशिक्षण को कवर नहीं करता है। वितरित प्रशिक्षण के लिए, बहु-gpu और वितरित प्रशिक्षण के लिए हमारी मार्गदर्शिका देखें।

एपीआई अवलोकन: पहला एंड-टू-एंड उदाहरण

किसी मॉडल के अंतर्निहित प्रशिक्षण लूप में डेटा पास करते समय, आपको या तो NumPy सरणियों का उपयोग करना चाहिए (यदि आपका डेटा छोटा है और मेमोरी में फिट बैठता है) या 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)

यहां बताया गया है कि विशिष्ट एंड-टू-एंड वर्कफ़्लो कैसा दिखता है, जिसमें निम्न शामिल हैं:

  • प्रशिक्षण
  • मूल प्रशिक्षण डेटा से उत्पन्न होल्डआउट सेट पर मान्यता
  • परीक्षण डेटा पर मूल्यांकन

हम इस उदाहरण के लिए 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() , जो मॉडल को "बैच_साइज" के "बैच" में डेटा को स्लाइस करके मॉडल को प्रशिक्षित करेगा, और बार-बार "एपोच" की दी गई संख्या के लिए संपूर्ण डेटासेट पर पुनरावृत्ति करेगा।

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.5821 - sparse_categorical_accuracy: 0.8361 - val_loss: 0.1893 - val_sparse_categorical_accuracy: 0.9483
Epoch 2/2
782/782 [==============================] - 2s 3ms/step - loss: 0.1676 - sparse_categorical_accuracy: 0.9500 - val_loss: 0.1631 - val_sparse_categorical_accuracy: 0.9488

लौटाया गया "इतिहास" ऑब्जेक्ट प्रशिक्षण के दौरान हानि मूल्यों और मीट्रिक मूल्यों का रिकॉर्ड रखता है:

history.history

{'loss': [0.344687819480896, 0.15941613912582397],
 'sparse_categorical_accuracy': [0.9019200205802917, 0.9523000121116638],
 'val_loss': [0.1892719268798828, 0.1630939543247223],
 'val_sparse_categorical_accuracy': [0.9483000040054321, 0.9488000273704529]}

हम मूल्यांकन के माध्यम से परीक्षण डेटा पर मॉडल का 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.1750 - sparse_categorical_accuracy: 0.9460
test loss, test acc: [0.17500483989715576, 0.9459999799728394]
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

कई बिल्ट-इन ऑप्टिमाइज़र, नुकसान और मैट्रिक्स उपलब्ध हैं

सामान्य तौर पर, आपको अपने स्वयं के नुकसान, मैट्रिक्स, या ऑप्टिमाइज़र को खरोंच करने से नहीं बनाना होगा, क्योंकि आपको जो कुछ चाहिए वह पहले से ही Keras 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.0265

<tensorflow.python.keras.callbacks.History at 0x7fb27c7a6cf8>

आप एक नुकसान समारोह है कि बगल में मापदंडों में ले जाता है की जरूरत है 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.0485

<tensorflow.python.keras.callbacks.History at 0x7fb27c64d438>

कस्टम मेट्रिक्स

यदि आपको एक मीट्रिक की आवश्यकता है जो एपीआई का हिस्सा नहीं है, तो आप आसानी से 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) , जो मीट्रिक की स्थिति को फिर से 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 [==============================] - 3s 2ms/step - loss: 0.5801 - categorical_true_positives: 22009.8493
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1717 - categorical_true_positives: 23861.7190
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1200 - categorical_true_positives: 24233.9246

<tensorflow.python.keras.callbacks.History at 0x7fb27c56f2e8>

नुकसान और मैट्रिक्स को संभालना जो मानक हस्ताक्षर के लायक नहीं है

नुकसान और मैट्रिक्स के भारी बहुमत की गणना y_true और y_pred से की जा सकती है, जहां y_pred आपके मॉडल का एक आउटपुट है। पर उनमें से सभी नहीं। उदाहरण के लिए, एक नियमितीकरण हानि के लिए केवल एक परत के सक्रियण की आवश्यकता हो सकती है (इस मामले में कोई लक्ष्य नहीं हैं), और यह सक्रियण एक मॉडल आउटपुट नहीं हो सकता है।

ऐसे मामलों में, आप कस्टम लेयर की कॉल विधि के अंदर से self.add_loss(loss_value) कॉल कर सकते हैं। इस तरह से जोड़े गए नुकसान प्रशिक्षण के दौरान "मुख्य" नुकसान में जुड़ जाते हैं (एक compile() करने के compile() पारित 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.2794

<tensorflow.python.keras.callbacks.History at 0x7fb27c4ea3c8>

आप 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.5627 - std_of_activation: 0.9609

<tensorflow.python.keras.callbacks.History at 0x7fb27c39e320>

फ़ंक्शनल एपीआई में , आप 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.6785 - std_of_activation: 0.0020

<tensorflow.python.keras.callbacks.History at 0x7fb27c2b4860>

ध्यान दें कि जब आप add_loss() माध्यम से नुकसान से add_loss() , तो एक नुकसान फ़ंक्शन के बिना compile() को कॉल 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 260ms/step - loss: 1.0546 - binary_accuracy: 0.0000e+00

<tensorflow.python.keras.callbacks.History at 0x7fb27c09cc88>

मल्टी-इनपुट मॉडल के प्रशिक्षण के बारे में अधिक जानकारी के लिए, मल्टी-इनपुट, मल्टी-आउटपुट मॉडल को डेटा पास करना अनुभाग देखें।

एक मान्यता होल्डआउट के अलावा स्वचालित रूप से सेट करना

पहली एंड-टू-एंड उदाहरण आपने देखा में, हम इस्तेमाल किया validation_data NumPy सरणी के एक टपल पारित करने के लिए तर्क (x_val, y_val) प्रत्येक युग के अंत में एक मान्यता नुकसान और सत्यापन मीट्रिक का मूल्यांकन करने के लिए मॉडल के लिए।

यहां एक अन्य विकल्प है: तर्क validation_split आपको validation_split लिए स्वचालित रूप से अपने प्रशिक्षण डेटा का हिस्सा आरक्षित करने की अनुमति देता है। तर्क मान सत्यापन के लिए आरक्षित किए जाने वाले डेटा के अंश का प्रतिनिधित्व करता है, इसलिए इसे 0 से अधिक संख्या में सेट किया जाना चाहिए और 1. से कम होना चाहिए। उदाहरण के लिए, validation_split=0.2 अर्थ है "सत्यापन के लिए डेटा का 20% उपयोग करें", और validation_split=0.6 अर्थ है " validation_split=0.6 के लिए डेटा का 60% उपयोग करें"।

जिस तरह से सत्यापन की गणना की जाती है, वह किसी भी फेरबदल से पहले, फिट कॉल द्वारा प्राप्त सरणियों के अंतिम x% नमूने लेने के द्वारा होती है।

ध्यान दें कि आप केवल NumPy डेटा के साथ प्रशिक्षण के समय validation_split उपयोग कर सकते हैं।

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.6332 - sparse_categorical_accuracy: 0.8232 - val_loss: 0.2352 - val_sparse_categorical_accuracy: 0.9284

<tensorflow.python.keras.callbacks.History at 0x7fb27014f0f0>

प्रशिक्षण और मूल्यांकन से tf.data डेटासेट

पिछले कुछ पैराग्राफों में, आपने देखा है कि नुकसान, मीट्रिक और ऑप्टिमाइज़र को कैसे हैंडल किया जाता है, और आपने देखा है कि कैसे फिट होने में validation_data और validation_split तर्क का उपयोग किया जाता है, जब आपका डेटा NumPy सरणियों के रूप में पास होता है।

आइए अब उस मामले पर एक नज़र डालते हैं जहां आपका डेटाtf.data.Dataset ऑब्जेक्ट के रूप में आता है।

tf.data API एक तेज़ और स्केलेबल डेटा को लोड करने और प्रीप्रोसेसिंग के लिए TensorFlow 2.0 में उपयोगिताओं का एक सेट है।

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 3ms/step - loss: 0.5405 - sparse_categorical_accuracy: 0.8524
Epoch 2/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1624 - sparse_categorical_accuracy: 0.9517
Epoch 3/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1150 - sparse_categorical_accuracy: 0.9660
Evaluate
157/157 [==============================] - 0s 2ms/step - loss: 0.1337 - sparse_categorical_accuracy: 0.9583

{'loss': 0.13374954462051392, 'sparse_categorical_accuracy': 0.958299994468689}

ध्यान दें कि डेटासेट प्रत्येक युग के अंत में रीसेट हो जाता है, इसलिए इसे अगले युग का पुन: उपयोग किया जा सकता है।

यदि आप इस डेटासेट से केवल कुछ विशिष्ट बैचों पर प्रशिक्षण चलाना चाहते हैं, तो आप steps_per_epoch तर्क पारित कर सकते हैं, जो यह निर्दिष्ट करता है कि अगले युग में जाने से पहले मॉडल को इस डेटासेट का उपयोग करके कितने चरण चलना चाहिए।

यदि आप ऐसा करते हैं, तो प्रत्येक युग के अंत में डेटासेट रीसेट नहीं किया जाता है, इसके बजाय हम बस अगले बैचों को खींचते रहते हैं। डेटासेट अंततः डेटा से बाहर चला जाएगा (जब तक कि यह एक अनन्त-लूपिंग डेटासेट नहीं है)।

0a0081a00 
Epoch 1/3
100/100 [==============================] - 1s 3ms/step - loss: 1.2317 - sparse_categorical_accuracy: 0.6776
Epoch 2/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3834 - sparse_categorical_accuracy: 0.8949
Epoch 3/3
100/100 [==============================] - 0s 3ms/step - loss: 0.3568 - sparse_categorical_accuracy: 0.8912

<tensorflow.python.keras.callbacks.History at 0x7fb21c3b7320>

एक सत्यापन डेटासेट का उपयोग करना

आप fit() में validation_data तर्क के रूप में Dataset उदाहरण पास कर सकते हैं:

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.5587 - sparse_categorical_accuracy: 0.8436 - val_loss: 0.1735 - val_sparse_categorical_accuracy: 0.9517

<tensorflow.python.keras.callbacks.History at 0x7fb21c19c7b8>

प्रत्येक युग के अंत में, मॉडल सत्यापन डेटासेट पर पुनरावृत्ति करेगा और सत्यापन हानि और सत्यापन मैट्रिक्स की गणना करेगा।

यदि आप इस डेटासेट से केवल कुछ विशिष्ट बैचों पर सत्यापन चलाना चाहते हैं, तो आप 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.5708 - sparse_categorical_accuracy: 0.8453 - val_loss: 0.2911 - val_sparse_categorical_accuracy: 0.9312

<tensorflow.python.keras.callbacks.History at 0x7fb21c31ff98>

ध्यान दें कि सत्यापन डेटासेट प्रत्येक उपयोग के बाद रीसेट हो जाएगा (ताकि आप हमेशा समान नमूनों पर युगांतर से युगांतर तक का मूल्यांकन करेंगे)।

Dataset ऑब्जेक्ट्स से प्रशिक्षण के दौरान तर्क validation_split (प्रशिक्षण डेटा से एक सेटआउट उत्पन्न करना) समर्थित नहीं है, क्योंकि इस सुविधा के लिए डेटासेट के नमूनों को अनुक्रमित करने की क्षमता की आवश्यकता होती है, जो Dataset एपीआई के साथ सामान्य रूप से संभव नहीं है।

अन्य इनपुट स्वरूपों का समर्थन किया

NumPy सरणी, उत्सुक tensors, और TensorFlow इसके अलावा Datasets , यह पांडा dataframes का उपयोग कर एक Keras मॉडल प्रशिक्षित करने के लिए संभव है, या अजगर जनरेटर से है कि डेटा और लेबल की उपज बैचों।

विशेष रूप से, keras.utils.Sequence वर्ग पायथन डेटा जनरेटर का निर्माण करने के लिए एक सरल इंटरफ़ेस प्रदान करता है जो मल्टीप्रोसेसिंग-जागरूक हैं और इसे फेरबदल किया जा सकता है।

सामान्य तौर पर, हम अनुशंसा करते हैं कि आप उपयोग करें:

  • यदि आपका डेटा छोटा है और मेमोरी में फिट बैठता है तो NumPy इनपुट डेटा
  • Dataset ऑब्जेक्ट यदि आपके पास बड़े डेटासेट हैं और आपको वितरित प्रशिक्षण करने की आवश्यकता है
  • Sequence ऑब्जेक्ट्स यदि आपके पास बड़े डेटासेट हैं और आपको बहुत सारे कस्टम पायथन-साइड प्रोसेसिंग करने की आवश्यकता है जो कि TensorFlow में नहीं किया जा सकता है (जैसे कि यदि आप डेटा लोडिंग या प्रीप्रोसेसिंग के लिए बाहरी पुस्तकालयों पर निर्भर हैं)।

इनपुट के रूप में keras.utils.Sequence ऑब्जेक्ट का उपयोग करना

keras.utils.Sequence एक उपयोगिता है जिसे आप दो महत्वपूर्ण गुणों के साथ पायथन जनरेटर प्राप्त करने के लिए उप-वर्ग कर सकते हैं:

  • यह मल्टीप्रोसेसिंग के साथ अच्छी तरह से काम करता है।
  • इसे फेरबदल किया जा सकता है (जैसे कि shuffle=True fit() में 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)

नमूना भार और वर्ग भार का उपयोग करना

डिफ़ॉल्ट सेटिंग्स के साथ एक नमूना का वजन डेटासेट में इसकी आवृत्ति से तय होता है। डेटा को भारित करने के दो तरीके हैं, नमूना आवृत्ति से स्वतंत्र:

  • वर्ग भार
  • नमूना वजन

वर्ग भार

यह Model.fit() के class_weight तर्क के लिए एक शब्दकोश पारित करके निर्धारित किया गया है। यह शब्दकोश उस वर्ग के वजन को इंगित करता है जिसका उपयोग इस वर्ग से संबंधित नमूनों के लिए किया जाना चाहिए।

इसका उपयोग बिना पुनरुत्पादन के वर्गों को संतुलित करने, या एक मॉडल को प्रशिक्षित करने के लिए किया जा सकता है जो किसी विशेष वर्ग को अधिक महत्व देता है।

उदाहरण के लिए, यदि वर्ग "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 2ms/step - loss: 0.6531 - sparse_categorical_accuracy: 0.8268

<tensorflow.python.keras.callbacks.History at 0x7fb27c4e6da0>

नमूना वजन

ठीक दानेदार नियंत्रण के लिए, या यदि आप एक क्लासिफायरियर का निर्माण नहीं कर रहे हैं, तो आप "नमूना भार" का उपयोग कर सकते हैं।

  • NumPy डेटा से प्रशिक्षण लेते समय: sample_weight तर्क को Model.fit() ।
  • जब tf.data या किसी अन्य प्रकार के tf.data से प्रशिक्षण लिया tf.data है: यील्ड (input_batch, label_batch, sample_weight_batch) ट्यूपल्स।

एक "नमूना वजन" सरणी संख्याओं की एक सरणी है जो निर्दिष्ट करती है कि बैच में प्रत्येक नमूने का कुल नुकसान की गणना में कितना वजन होना चाहिए। यह आमतौर पर असंतुलित वर्गीकरण समस्याओं (शायद ही कभी देखे गए वर्गों को अधिक वजन देने के लिए किया जा रहा है) में उपयोग किया जाता है।

जब उपयोग किए जाने वाले वज़न वाले होते हैं और शून्य होते हैं, तो सरणी को नुकसान फ़ंक्शन के लिए मुखौटा के रूप में इस्तेमाल किया जा सकता है (पूरी तरह से कुल नुकसान के लिए कुछ नमूनों के योगदान को त्यागना)।

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.6471 - sparse_categorical_accuracy: 0.8342

<tensorflow.python.keras.callbacks.History at 0x7fb21c1257f0>

यहाँ एक मिलान 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 3ms/step - loss: 0.6161 - sparse_categorical_accuracy: 0.8486

<tensorflow.python.keras.callbacks.History at 0x7fb27c7a46a0>

मल्टी-इनपुट, मल्टी-आउटपुट मॉडल के लिए डेटा पास करना

पिछले उदाहरणों में, हम एक एकल इनपुट (आकार का (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 से अधिक आउटपुट हैं, तो हम स्पष्ट नाम और dicts के उपयोग की सलाह देते हैं।

यह अलग उत्पादन विशेष घाटे के लिए अलग अलग वजन देने के लिए (उदाहरण के लिए, एक, हमारे उदाहरण में "स्कोर" नुकसान विशेषाधिकार करना चाहते हो सकता है वर्ग नुकसान के महत्व को 2 गुना तक अधिक देकर) का उपयोग कर, संभव है 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()},
)

एक मल्टी-इनपुट या मल्टी-आउटपुट मॉडल के लिए डेटा को फिट करने के लिए एक समान तरीके से काम करता है जैसे कि संकलन में एक हानि फ़ंक्शन को निर्दिष्ट करना: आप 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 [==============================] - 2s 12ms/step - loss: 19.3697 - score_output_loss: 1.3639 - class_output_loss: 18.0058
4/4 [==============================] - 0s 6ms/step - loss: 17.6548 - score_output_loss: 0.7146 - class_output_loss: 16.9402

<tensorflow.python.keras.callbacks.History at 0x7fb27c5d51d0>

यहाँ Dataset उपयोग मामला है: जैसा कि हमने NumPy सरणियों के लिए किया था, उसी तरह Dataset को टिक्स का वापस लौटना चाहिए।

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 29ms/step - loss: 17.3215 - score_output_loss: 0.5076 - class_output_loss: 16.8139

<tensorflow.python.keras.callbacks.History at 0x7fb27c46b438>

कॉलबैक का उपयोग करना

केरस में कॉलबैक ऐसी वस्तुएं हैं जिन्हें प्रशिक्षण के दौरान अलग-अलग बिंदुओं पर बुलाया जाता है (एक युग की शुरुआत में, एक बैच के अंत में, एक युग के अंत में, आदि) और जिसका उपयोग व्यवहार को लागू करने के लिए किया जा सकता है जैसे:

  • प्रशिक्षण के दौरान विभिन्न बिंदुओं पर सत्यापन करना (बिल्ट-इन-प्रति-युग सत्यापन से परे)
  • मॉडल को नियमित अंतराल पर चेक करना या जब यह एक निश्चित सटीकता सीमा से अधिक हो
  • जब प्रशिक्षण पठार लगता है तो मॉडल की सीखने की दर को बदलना
  • जब प्रशिक्षण पठार लगता है तो ऊपर की परतों को बारीक करना
  • जब प्रशिक्षण समाप्त होता है या जहां एक निश्चित प्रदर्शन सीमा पार हो जाती है, तो ईमेल या त्वरित संदेश सूचना भेजना
  • आदि।

कॉलबैक को 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.6313 - sparse_categorical_accuracy: 0.8207 - val_loss: 0.2313 - val_sparse_categorical_accuracy: 0.9307
Epoch 2/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1827 - sparse_categorical_accuracy: 0.9459 - val_loss: 0.1989 - val_sparse_categorical_accuracy: 0.9410
Epoch 3/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1298 - sparse_categorical_accuracy: 0.9619 - val_loss: 0.1561 - val_sparse_categorical_accuracy: 0.9529
Epoch 4/20
625/625 [==============================] - 2s 2ms/step - loss: 0.0977 - sparse_categorical_accuracy: 0.9713 - val_loss: 0.1434 - val_sparse_categorical_accuracy: 0.9576
Epoch 5/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0799 - sparse_categorical_accuracy: 0.9755 - val_loss: 0.1364 - val_sparse_categorical_accuracy: 0.9614
Epoch 6/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0648 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.1351 - val_sparse_categorical_accuracy: 0.9617
Epoch 00006: early stopping

<tensorflow.python.keras.callbacks.History at 0x7fb29ca68940>

कई बिल्ट-इन कॉलबैक उपलब्ध हैं

  • ModelCheckpoint : समय-समय पर मॉडल को सहेजें।
  • EarlyStopping : प्रशिक्षण बंद करो जब प्रशिक्षण अब सत्यापन मैट्रिक्स में सुधार नहीं कर रहा है।
  • TensorBoard : समय-समय पर मॉडल लॉग लिखें जो TensorBoard (अनुभाग "विज़ुअलाइज़ेशन" में अधिक विवरण) में देखे जा सकते हैं।
  • CSVLogger : CSV फ़ाइल में हानि और मैट्रिक्स डेटा स्ट्रीम करता है।
  • आदि।

पूरी सूची के लिए कॉलबैक दस्तावेज़ देखें।

अपना खुद का कॉलबैक लिखना

आप बेस क्लास keras.callbacks.Callback विस्तार करके एक कस्टम कॉलबैक बना सकते हैं। एक कॉलबैक को क्लास प्रॉपर्टी 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 3ms/step - loss: 0.6208 - sparse_categorical_accuracy: 0.8258 - val_loss: 0.2241 - val_sparse_categorical_accuracy: 0.9326

Epoch 00001: val_loss improved from inf to 0.22410, saving model to mymodel_1
INFO:tensorflow:Assets written to: mymodel_1/assets
Epoch 2/2
625/625 [==============================] - 2s 3ms/step - loss: 0.1820 - sparse_categorical_accuracy: 0.9470 - val_loss: 0.1621 - val_sparse_categorical_accuracy: 0.9497

Epoch 00002: val_loss improved from 0.22410 to 0.16212, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets

<tensorflow.python.keras.callbacks.History at 0x7fb21c3e8a20>

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
  94/1563 [>.............................] - ETA: 3s - loss: 1.4324 - sparse_categorical_accuracy: 0.5773INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.96/assets
 193/1563 [==>...........................] - ETA: 5s - loss: 1.1162 - sparse_categorical_accuracy: 0.6814INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.69/assets
 290/1563 [====>.........................] - ETA: 6s - loss: 0.9546 - sparse_categorical_accuracy: 0.7298INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.57/assets
 395/1563 [======>.......................] - ETA: 6s - loss: 0.8447 - sparse_categorical_accuracy: 0.7617INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.51/assets
 493/1563 [========>.....................] - ETA: 6s - loss: 0.7744 - sparse_categorical_accuracy: 0.7817INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.47/assets
 598/1563 [==========>...................] - ETA: 5s - loss: 0.7186 - sparse_categorical_accuracy: 0.7973INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.44/assets
 696/1563 [============>.................] - ETA: 5s - loss: 0.6778 - sparse_categorical_accuracy: 0.8086INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.42/assets
 794/1563 [==============>...............] - ETA: 4s - loss: 0.6445 - sparse_categorical_accuracy: 0.8178INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.40/assets
 898/1563 [================>.............] - ETA: 4s - loss: 0.6146 - sparse_categorical_accuracy: 0.8260INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.38/assets
 995/1563 [==================>...........] - ETA: 3s - loss: 0.5907 - sparse_categorical_accuracy: 0.8326INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.36/assets
1095/1563 [====================>.........] - ETA: 2s - loss: 0.5693 - sparse_categorical_accuracy: 0.8385INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.35/assets
1196/1563 [=====================>........] - ETA: 2s - loss: 0.5503 - sparse_categorical_accuracy: 0.8437INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1297/1563 [=======================>......] - ETA: 1s - loss: 0.5334 - sparse_categorical_accuracy: 0.8484INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1391/1563 [=========================>....] - ETA: 1s - loss: 0.5193 - sparse_categorical_accuracy: 0.8523INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1497/1563 [===========================>..] - ETA: 0s - loss: 0.5050 - sparse_categorical_accuracy: 0.8563INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.31/assets
1563/1563 [==============================] - 11s 6ms/step - loss: 0.4966 - sparse_categorical_accuracy: 0.8586

<tensorflow.python.keras.callbacks.History at 0x7fb2700955c0>

आप कॉलिंग मॉडल को बचाने और पुनर्स्थापित करने के लिए अपना कॉलबैक भी लिखते हैं।

सीरियलाइज़ेशन और सेविंग पर पूरी गाइड के लिए, मॉडल्स को सेविंग और सीरीज़ करने के लिए गाइड देखें।

सीखने की दर अनुसूची का उपयोग करना

एक सामान्य पैटर्न जब गहन शिक्षण मॉडल का प्रशिक्षण होता है, तो धीरे-धीरे प्रशिक्षण की प्रगति के रूप में सीखने को कम करना चाहिए। यह आमतौर पर "सीखने की दर में गिरावट" के रूप में जाना जाता है।

सीखने की क्षय अनुसूची स्थिर हो सकती है (अग्रिम में, वर्तमान युग या वर्तमान बैच सूचकांक के एक समारोह के रूप में), या गतिशील (मॉडल के वर्तमान व्यवहार का जवाब देते हुए, विशेष रूप से सत्यापन हानि)।

एक आशावादी के लिए एक कार्यक्रम गुजर रहा है

आप किसी शेड्यूल ऑब्जेक्ट को अपने ऑप्टिमाइज़र में 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 परतों द्वारा सीखे गए

यदि आपने पाइप के साथ TensorFlow स्थापित किया है, तो आपको कमांड लाइन से TensorBoard लॉन्च करने में सक्षम होना चाहिए:

tensorboard --logdir=/full_path_to_your_logs

TensorBoard कॉलबैक का उपयोग करना

टेनसोरबोर्ड को केरस मॉडल और फिट विधि के साथ उपयोग करने का सबसे आसान तरीका 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 0x7fb21c22deb8>

अधिक जानकारी के लिए, TensorBoard कॉलबैक के लिए दस्तावेज़ देखें।